Use __PMT not __P for function pointers.
[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 <errno.h>
21 #include <limits.h>
22 #include <sched.h>
23 #include <unistd.h>
24
25 #define __need_sigset_t
26 #include <signal.h>
27 #define __need_timespec
28 #include <time.h>
29
30 /* Linux has no ENOTSUP error code.  */
31 #ifndef ENOTSUP
32 #define ENOTSUP EOPNOTSUPP
33 #endif
34
35
36 __BEGIN_DECLS
37
38 /*** Types ***/
39
40 /* Thread identifiers */
41 typedef unsigned long int pthread_t;
42
43 /* Thread descriptors */
44 typedef struct _pthread_descr_struct *_pthread_descr;
45
46 /* Fast locks (not abstract because mutexes and conditions aren't abstract). */
47 struct _pthread_fastlock
48 {
49   long int status;              /* "Free" or "taken" or head of waiting list */
50   int spinlock;                 /* For compare-and-swap emulation */
51 };
52
53 /* Mutexes (not abstract because of PTHREAD_MUTEX_INITIALIZER).  */
54 /* (The layout is unnatural to maintain binary compatibility
55     with earlier releases of LinuxThreads.) */
56
57 typedef struct
58 {
59   int m_reserved;               /* Reserved for future use */
60   int m_count;                  /* Depth of recursive locking */
61   _pthread_descr m_owner;       /* Owner thread (if recursive or errcheck) */
62   int m_kind;                   /* Mutex kind: fast, recursive or errcheck */
63   struct _pthread_fastlock m_lock; /* Underlying fast lock */
64 } pthread_mutex_t;
65
66 #define PTHREAD_MUTEX_INITIALIZER \
67   {0, 0, 0, PTHREAD_MUTEX_FAST_NP, {0, 0}}
68 #define PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP \
69   {0, 0, 0, PTHREAD_MUTEX_RECURSIVE_NP, {0, 0}}
70
71 /* Conditions (not abstract because of PTHREAD_COND_INITIALIZER */
72 typedef struct
73 {
74   struct _pthread_fastlock c_lock; /* Protect against concurrent access */
75   _pthread_descr c_waiting;        /* Threads waiting on this condition */
76 } pthread_cond_t;
77
78 #define PTHREAD_COND_INITIALIZER {{0, 0}, 0}
79
80 #ifdef __USE_UNIX98
81 /* Read-write locks.  */
82 typedef struct
83 {
84   struct _pthread_fastlock rw_lock; /* Lock to guarantee mutual exclusion */
85   int rw_readers;               /* Number of readers */
86   _pthread_descr rw_writer;     /* Identity of writer, or NULL if none */
87   _pthread_descr rw_read_waiting; /* Threads waiting for reading */
88   _pthread_descr rw_write_waiting; /* Threads waiting for writing */
89   int rw_kind;                  /* Reader/Writer preference selection */
90   int rw_pshared;               /* Shared between processes or not */
91 } pthread_rwlock_t;
92
93 # define PTHREAD_RWLOCK_INITIALIZER \
94   { {0, 0}, 0, NULL, NULL, NULL,                                              \
95     PTHREAD_RWLOCK_DEFAULT_NP, PTHREAD_PROCESS_PRIVATE }
96 #endif
97
98 /* Attributes */
99
100 enum
101 {
102   PTHREAD_CREATE_JOINABLE,
103 #define PTHREAD_CREATE_JOINABLE PTHREAD_CREATE_JOINABLE
104   PTHREAD_CREATE_DETACHED
105 #define PTHREAD_CREATE_DETACHED PTHREAD_CREATE_DETACHED
106 };
107
108 enum
109 {
110   PTHREAD_INHERIT_SCHED,
111 #define PTHREAD_INHERIT_SCHED   PTHREAD_INHERIT_SCHED
112   PTHREAD_EXPLICIT_SCHED
113 #define PTHREAD_EXPLICIT_SCHED  PTHREAD_EXPLICIT_SCHED
114 };
115
116 enum
117 {
118   PTHREAD_SCOPE_SYSTEM,
119 #define PTHREAD_SCOPE_SYSTEM    PTHREAD_SCOPE_SYSTEM
120   PTHREAD_SCOPE_PROCESS
121 #define PTHREAD_SCOPE_PROCESS   PTHREAD_SCOPE_PROCESS
122 };
123
124 typedef struct
125 {
126   int detachstate;
127   int schedpolicy;
128   struct sched_param schedparam;
129   int inheritsched;
130   int scope;
131   size_t guardsize;
132   int stackaddr_set;
133   void *stackaddr;
134   size_t stacksize;
135 } pthread_attr_t;
136
137 enum
138 {
139   PTHREAD_MUTEX_FAST_NP,
140   PTHREAD_MUTEX_RECURSIVE_NP,
141   PTHREAD_MUTEX_ERRORCHECK_NP
142 #ifdef __USE_UNIX98
143   ,
144   PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_FAST_NP,
145   PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP,
146   PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP,
147   PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL
148 #endif
149 };
150
151 typedef struct
152 {
153   int mutexkind;
154 } pthread_mutexattr_t;
155
156 typedef struct
157 {
158   int dummy;
159 } pthread_condattr_t;
160
161 #ifdef __USE_UNIX98
162 enum
163 {
164   PTHREAD_PROCESS_PRIVATE,
165 # define PTHREAD_PROCESS_PRIVATE        PTHREAD_PROCESS_PRIVATE
166   PTHREAD_PROCESS_SHARED
167 # define PTHREAD_PROCESS_SHARED         PTHREAD_PROCESS_SHARED
168 };
169
170 enum
171 {
172   PTHREAD_RWLOCK_PREFER_READER_NP,
173   PTHREAD_RWLOCK_PREFER_WRITER_NP,
174   PTHREAD_RWLOCK_DEFAULT_NP = PTHREAD_RWLOCK_PREFER_WRITER_NP
175 };
176
177 typedef struct
178 {
179   int lockkind;
180   int pshared;
181 } pthread_rwlockattr_t;
182 #endif
183
184 /* Keys for thread-specific data */
185
186 typedef unsigned int pthread_key_t;
187
188 /* Once-only execution */
189
190 typedef int pthread_once_t;
191
192 #define PTHREAD_ONCE_INIT 0
193
194 /* Cleanup buffers */
195
196 struct _pthread_cleanup_buffer
197 {
198   void (*routine) __PMT ((void *));     /* Function to call.  */
199   void *arg;                            /* Its argument.  */
200   int canceltype;                       /* Saved cancellation type. */
201   struct _pthread_cleanup_buffer *prev; /* Chaining of cleanup functions.  */
202 };
203
204 /* Cancellation */
205
206 enum
207 {
208   PTHREAD_CANCEL_ENABLE,
209 #define PTHREAD_CANCEL_ENABLE   PTHREAD_CANCEL_ENABLE
210   PTHREAD_CANCEL_DISABLE
211 #define PTHREAD_CANCEL_DISABLE  PTHREAD_CANCEL_DISABLE
212 };
213 enum
214 {
215   PTHREAD_CANCEL_DEFERRED,
216 #define PTHREAD_CANCEL_DEFERRED PTHREAD_CANCEL_DEFERRED
217   PTHREAD_CANCEL_ASYNCHRONOUS
218 #define PTHREAD_CANCEL_ASYNCHRONOUS     PTHREAD_CANCEL_ASYNCHRONOUS
219 };
220 #define PTHREAD_CANCELED ((void *) -1)
221
222
223 /* Function for handling threads.  */
224
225 /* Create a thread with given attributes ATTR (or default attributes
226    if ATTR is NULL), and call function START_ROUTINE with given
227    arguments ARG.  */
228 extern int pthread_create __P ((pthread_t *__thread,
229                                 __const pthread_attr_t *__attr,
230                                 void *(*__start_routine) (void *),
231                                 void *__arg));
232
233 /* Obtain the identifier of the current thread.  */
234 extern pthread_t pthread_self __P ((void));
235
236 /* Compare two thread identifiers.  */
237 extern int pthread_equal __P ((pthread_t __thread1, pthread_t __thread2));
238
239 /* Terminate calling thread.  */
240 extern void pthread_exit __P ((void *__retval)) __attribute__ ((__noreturn__));
241
242 /* Make calling thread wait for termination of the thread TH.  The
243    exit status of the thread is stored in *THREAD_RETURN, if THREAD_RETURN
244    is not NULL.  */
245 extern int pthread_join __P ((pthread_t __th, void **__thread_return));
246
247 /* Indicate that the thread TH is never to be joined with PTHREAD_JOIN.
248    The resources of TH will therefore be freed immediately when it
249    terminates, instead of waiting for another thread to perform PTHREAD_JOIN
250    on it. */
251 extern int pthread_detach __P ((pthread_t __th));
252
253
254 /* Functions for handling attributes.  */
255
256 /* Initialize thread attribute *ATTR with default attributes
257    (detachstate is PTHREAD_JOINABLE, scheduling policy is SCHED_OTHER,
258     no user-provided stack).  */
259 extern int pthread_attr_init __P ((pthread_attr_t *__attr));
260
261 /* Destroy thread attribute *ATTR.  */
262 extern int pthread_attr_destroy __P ((pthread_attr_t *__attr));
263
264 /* Set the `detachstate' attribute in *ATTR according to DETACHSTATE.  */
265 extern int pthread_attr_setdetachstate __P ((pthread_attr_t *__attr,
266                                              int __detachstate));
267
268 /* Return in *DETACHSTATE the `detachstate' attribute in *ATTR.  */
269 extern int pthread_attr_getdetachstate __P ((__const pthread_attr_t *__attr,
270                                              int *__detachstate));
271
272 /* Set scheduling parameters (priority, etc) in *ATTR according to PARAM.  */
273 extern int pthread_attr_setschedparam __P ((pthread_attr_t *__attr,
274                                         __const struct sched_param *__param));
275
276 /* Return in *PARAM the scheduling parameters of *ATTR.  */
277 extern int pthread_attr_getschedparam __P ((__const pthread_attr_t *__attr,
278                                             struct sched_param *__param));
279
280 /* Set scheduling policy in *ATTR according to POLICY.  */
281 extern int pthread_attr_setschedpolicy __P ((pthread_attr_t *__attr,
282                                              int __policy));
283
284 /* Return in *POLICY the scheduling policy of *ATTR.  */
285 extern int pthread_attr_getschedpolicy __P ((__const pthread_attr_t *__attr,
286                                              int *__policy));
287
288 /* Set scheduling inheritance mode in *ATTR according to INHERIT.  */
289 extern int pthread_attr_setinheritsched __P ((pthread_attr_t *__attr,
290                                               int __inherit));
291
292 /* Return in *INHERIT the scheduling inheritance mode of *ATTR.  */
293 extern int pthread_attr_getinheritsched __P ((__const pthread_attr_t *__attr,
294                                               int *__inherit));
295
296 /* Set scheduling contention scope in *ATTR according to SCOPE.  */
297 extern int pthread_attr_setscope __P ((pthread_attr_t *__attr, int __scope));
298
299 /* Return in *SCOPE the scheduling contention scope of *ATTR.  */
300 extern int pthread_attr_getscope __P ((__const pthread_attr_t *__attr,
301                                        int *__scope));
302
303 #ifdef __USE_UNIX98
304 /* Set the size of the guard area at the bottom of the thread.  */
305 extern int __pthread_attr_setguardsize __P ((pthread_attr_t *__attr,
306                                              size_t __guardsize));
307 extern int pthread_attr_setguardsize __P ((pthread_attr_t *__attr,
308                                            size_t __guardsize));
309
310 /* Get the size of the guard area at the bottom of the thread.  */
311 extern int __pthread_attr_getguardsize __P ((__const pthread_attr_t *__attr,
312                                              size_t *__guardsize));
313 extern int pthread_attr_getguardsize __P ((__const pthread_attr_t *__attr,
314                                            size_t *__guardsize));
315 #endif
316
317 /* Set the starting address of the stack of the thread to be created.
318    Depending on whether the stack grows up or doen the value must either
319    be higher or lower than all the address in the memory block.  The
320    minimal size of the block must be PTHREAD_STACK_SIZE.  */
321 extern int __pthread_attr_setstackaddr __P ((pthread_attr_t *__attr,
322                                              void *__stackaddr));
323 extern int pthread_attr_setstackaddr __P ((pthread_attr_t *__attr,
324                                            void *__stackaddr));
325
326 /* Return the previously set address for the stack.  */
327 extern int __pthread_attr_getstackaddr __P ((__const pthread_attr_t *__attr,
328                                              void **__stackaddr));
329 extern int pthread_attr_getstackaddr __P ((__const pthread_attr_t *__attr,
330                                            void **__stackaddr));
331
332 /* Add information about the minimum stack size needed for the thread
333    to be started.  This size must never be less than PTHREAD_STACK_SIZE
334    and must also not exceed the system limits.  */
335 extern int __pthread_attr_setstacksize __P ((pthread_attr_t *__attr,
336                                              size_t __stacksize));
337 extern int pthread_attr_setstacksize __P ((pthread_attr_t *__attr,
338                                            size_t __stacksize));
339
340 /* Return the currently used minimal stack size.  */
341 extern int __pthread_attr_getstacksize __P ((__const pthread_attr_t *__attr,
342                                              size_t *__stacksize));
343 extern int pthread_attr_getstacksize __P ((__const pthread_attr_t *__attr,
344                                            size_t *__stacksize));
345
346 /* Functions for scheduling control. */
347
348 /* Set the scheduling parameters for TARGET_THREAD according to POLICY
349    and *PARAM. */
350 extern int pthread_setschedparam __P ((pthread_t __target_thread, int __policy,
351                                        __const struct sched_param *__param));
352
353 /* Return in *POLICY and *PARAM the scheduling parameters for TARGET_THREAD. */
354 extern int pthread_getschedparam __P ((pthread_t __target_thread,
355                                        int *__policy,
356                                        struct sched_param *__param));
357
358 #ifdef __USE_UNIX98
359 /* Determine  level of concurrency.  */
360 extern int __pthread_getconcurrency __P ((void));
361 extern int pthread_getconcurrency __P ((void));
362
363 /* Set new concurrency level to LEVEL.  */
364 extern int __pthread_setconcurrency __P ((int __level));
365 extern int pthread_setconcurrency __P ((int __level));
366 #endif
367
368 /* Functions for mutex handling. */
369
370 /* Initialize MUTEX using attributes in *MUTEX_ATTR, or use the
371    default values if later is NULL.  */
372 extern int __pthread_mutex_init __P ((pthread_mutex_t *__mutex,
373                                    __const pthread_mutexattr_t *__mutex_attr));
374 extern int pthread_mutex_init __P ((pthread_mutex_t *__mutex,
375                                    __const pthread_mutexattr_t *__mutex_attr));
376
377 /* Destroy MUTEX.  */
378 extern int __pthread_mutex_destroy __P ((pthread_mutex_t *__mutex));
379 extern int pthread_mutex_destroy __P ((pthread_mutex_t *__mutex));
380
381 /* Try to lock MUTEX.  */
382 extern int __pthread_mutex_trylock __P ((pthread_mutex_t *__mutex));
383 extern int pthread_mutex_trylock __P ((pthread_mutex_t *__mutex));
384
385 /* Wait until lock for MUTEX becomes available and lock it.  */
386 extern int __pthread_mutex_lock __P ((pthread_mutex_t *__mutex));
387 extern int pthread_mutex_lock __P ((pthread_mutex_t *__mutex));
388
389 /* Unlock MUTEX.  */
390 extern int __pthread_mutex_unlock __P ((pthread_mutex_t *__mutex));
391 extern int pthread_mutex_unlock __P ((pthread_mutex_t *__mutex));
392
393
394 /* Functions for handling mutex attributes.  */
395
396 /* Initialize mutex attribute object ATTR with default attributes
397    (kind is PTHREAD_MUTEX_FAST_NP).  */
398 extern int __pthread_mutexattr_init __P ((pthread_mutexattr_t *__attr));
399 extern int pthread_mutexattr_init __P ((pthread_mutexattr_t *__attr));
400
401 /* Destroy mutex attribute object ATTR.  */
402 extern int __pthread_mutexattr_destroy __P ((pthread_mutexattr_t *__attr));
403 extern int pthread_mutexattr_destroy __P ((pthread_mutexattr_t *__attr));
404
405 /* Set the mutex kind attribute in *ATTR to KIND (either PTHREAD_MUTEX_FAST_NP
406    or PTHREAD_MUTEX_RECURSIVE_NP). */
407 extern int __pthread_mutexattr_setkind_np __P ((pthread_mutexattr_t *__attr,
408                                                 int __kind));
409 extern int pthread_mutexattr_setkind_np __P ((pthread_mutexattr_t *__attr,
410                                               int __kind));
411 /* Return in *KIND the mutex kind attribute in *ATTR. */
412 extern int pthread_mutexattr_getkind_np __P ((__const pthread_mutexattr_t *__attr,
413                                               int *__kind));
414
415
416 /* Functions for handling conditional variables.  */
417
418 /* Initialize condition variable COND using attributes ATTR, or use
419    the default values if later is NULL.  */
420 extern int pthread_cond_init __P ((pthread_cond_t *__cond,
421                                    __const pthread_condattr_t *__cond_attr));
422
423 /* Destroy condition variable COND.  */
424 extern int pthread_cond_destroy __P ((pthread_cond_t *__cond));
425
426 /* Wake up one thread waiting for condition variable COND.  */
427 extern int pthread_cond_signal __P ((pthread_cond_t *__cond));
428
429 /* Wake up all threads waiting for condition variables COND.  */
430 extern int pthread_cond_broadcast __P ((pthread_cond_t *__cond));
431
432 /* Wait for condition variable COND to be signaled or broadcast.
433    MUTEX is assumed to be locked before.  */
434 extern int pthread_cond_wait __P ((pthread_cond_t *__cond,
435                                    pthread_mutex_t *__mutex));
436
437 /* Wait for condition variable COND to be signaled or broadcast until
438    ABSTIME.  MUTEX is assumed to be locked before.  ABSTIME is an
439    absolute time specification; zero is the beginning of the epoch
440    (00:00:00 GMT, January 1, 1970). */
441 extern int pthread_cond_timedwait __P ((pthread_cond_t *__cond,
442                                         pthread_mutex_t *__mutex,
443                                         __const struct timespec *__abstime));
444
445 /* Functions for handling condition variable attributes.  */
446
447 /* Initialize condition variable attribute ATTR.  */
448 extern int pthread_condattr_init __P ((pthread_condattr_t *__attr));
449
450 /* Destroy condition variable attribute ATTR.  */
451 extern int pthread_condattr_destroy __P ((pthread_condattr_t *__attr));
452
453
454 #ifdef __USE_UNIX98
455 /* Functions for handling read-write locks.  */
456
457 /* Initialize read-write lock RWLOCK using attributes ATTR, or use
458    the default values if later is NULL.  */
459 extern int pthread_rwlock_init __P ((pthread_rwlock_t *__rwlock,
460                                      __const pthread_rwlockattr_t *__attr));
461
462 /* Destroy read-write lock RWLOCK.  */
463 extern int pthread_rwlock_destroy __P ((pthread_rwlock_t *__rwlock));
464
465 /* Acquire read lock for RWLOCK.  */
466 extern int pthread_rwlock_rdlock __P ((pthread_rwlock_t *__rwlock));
467
468 /* Try to acquire read lock for RWLOCK.  */
469 extern int pthread_rwlock_tryrdlock __P ((pthread_rwlock_t *__rwlock));
470
471 /* Acquire write lock for RWLOCK.  */
472 extern int pthread_rwlock_wrlock __P ((pthread_rwlock_t *__rwlock));
473
474 /* Try to acquire writelock for RWLOCK.  */
475 extern int pthread_rwlock_trywrlock __P ((pthread_rwlock_t *__rwlock));
476
477 /* Unlock RWLOCK.  */
478 extern int pthread_rwlock_unlock __P ((pthread_rwlock_t *__rwlock));
479
480
481 /* Functions for handling read-write lock attributes.  */
482
483 /* Initialize attribute object ATTR with default values.  */
484 extern int pthread_rwlockattr_init __P ((pthread_rwlockattr_t *__attr));
485
486 /* Destroy attribute object ATTR.  */
487 extern int pthread_rwlockattr_destroy __P ((pthread_rwlockattr_t *__attr));
488
489 /* Return current setting of process-shared attribute of ATTR in PSHARED.  */
490 extern int pthread_rwlockattr_getpshared __P ((__const
491                                                pthread_rwlockattr_t *__attr,
492                                                int *__pshared));
493
494 /* Set process-shared attribute of ATTR to PSHARED.  */
495 extern int pthread_rwlockattr_setpshared __P ((pthread_rwlockattr_t *__attr,
496                                                int __pshared));
497
498 /* Return current setting of reader/writer preference.  */
499 extern int pthread_rwlockattr_getkind_np __P ((__const
500                                                pthread_rwlockattr_t *__attr,
501                                                int *__pref));
502
503 /* Set reader/write preference.  */
504 extern int pthread_rwlockattr_setkind_np __P ((pthread_rwlockattr_t *__attr,
505                                                int __pref));
506 #endif
507
508
509 /* Functions for handling thread-specific data */
510
511 /* Create a key value identifying a location in the thread-specific data
512    area.  Each thread maintains a distinct thread-specific data area.
513    DESTR_FUNCTION, if non-NULL, is called with
514    the value associated to that key when the key is destroyed.
515    DESTR_FUNCTION is not called if the value associated is NULL
516    when the key is destroyed. */
517 extern int __pthread_key_create __P ((pthread_key_t *__key,
518                                       void (*__destr_function) (void *)));
519 extern int pthread_key_create __P ((pthread_key_t *__key,
520                                     void (*__destr_function) (void *)));
521
522 /* Destroy KEY.  */
523 extern int pthread_key_delete __P ((pthread_key_t __key));
524
525 /* Store POINTER in the thread-specific data slot identified by KEY. */
526 extern int __pthread_setspecific __P ((pthread_key_t __key,
527                                        __const void *__pointer));
528 extern int pthread_setspecific __P ((pthread_key_t __key,
529                                      __const void *__pointer));
530
531 /* Return current value of the thread-specific data slot identified by KEY.  */
532 extern void *__pthread_getspecific __P ((pthread_key_t __key));
533 extern void *pthread_getspecific __P ((pthread_key_t __key));
534
535
536 /* Functions for handling initialization */
537
538 /* Guarantee that the initialization function INIT_ROUTINE will be called
539    only once, even if pthread_once is executed several times with the
540    same ONCE_CONTROL argument. ONCE_CONTROL must point to a static or
541    extern variable initialized to PTHREAD_ONCE_INIT. */
542 extern int __pthread_once __P ((pthread_once_t *__once_control,
543                                 void (*__init_routine) (void)));
544 extern int pthread_once __P ((pthread_once_t *__once_control,
545                               void (*__init_routine) (void)));
546
547
548 /* Functions for handling cancellation. */
549
550 /* Set cancelability state of current thread to STATE, returning old
551    state in *OLDSTATE if OLDSTATE is not NULL.  */
552 extern int pthread_setcancelstate __P ((int __state, int *__oldstate));
553
554 /* Set cancellation state of current thread to TYPE, returning the old
555    type in *OLDTYPE if OLDTYPE is not NULL.  */
556 extern int __pthread_setcanceltype __P ((int __type, int *__oldtype));
557 extern int pthread_setcanceltype __P ((int __type, int *__oldtype));
558
559 /* Cancel THREAD immediately or at the next possibility.  */
560 extern int pthread_cancel __P ((pthread_t __thread));
561
562 /* Test for pending cancellation for the current thread and terminate
563    the thread as per pthread_exit(PTHREAD_CANCELED) if it has been
564    cancelled. */
565 extern void pthread_testcancel __P ((void));
566
567
568 /* Install a cleanup handler: ROUTINE will be called with arguments ARG
569    when the thread is cancelled or calls pthread_exit.  ROUTINE will also
570    be called with arguments ARG when the matching pthread_cleanup_pop
571    is executed with non-zero EXECUTE argument.
572    pthread_cleanup_push and pthread_cleanup_pop are macros and must always
573    be used in matching pairs at the same nesting level of braces. */
574
575 #define pthread_cleanup_push(routine,arg)                                     \
576   { struct _pthread_cleanup_buffer _buffer;                                   \
577     _pthread_cleanup_push (&_buffer, (routine), (arg));
578
579 extern void _pthread_cleanup_push __P ((struct _pthread_cleanup_buffer *__buffer,
580                                         void (*__routine) (void *),
581                                         void *__arg));
582
583 /* Remove a cleanup handler installed by the matching pthread_cleanup_push.
584    If EXECUTE is non-zero, the handler function is called. */
585
586 #define pthread_cleanup_pop(execute)                                          \
587     _pthread_cleanup_pop (&_buffer, (execute)); }
588
589 extern void _pthread_cleanup_pop __P ((struct _pthread_cleanup_buffer *__buffer,
590                                        int __execute));
591
592 /* Install a cleanup handler as pthread_cleanup_push does, but also
593    saves the current cancellation type and set it to deferred cancellation. */
594
595 #define pthread_cleanup_push_defer_np(routine,arg)                            \
596   { struct _pthread_cleanup_buffer _buffer;                                   \
597     _pthread_cleanup_push_defer (&_buffer, (routine), (arg));
598
599 extern void _pthread_cleanup_push_defer __P ((struct _pthread_cleanup_buffer *__buffer,
600                                               void (*__routine) (void *),
601                                               void *__arg));
602
603 /* Remove a cleanup handler as pthread_cleanup_pop does, but also
604    restores the cancellation type that was in effect when the matching
605    pthread_cleanup_push_defer was called. */
606
607 #define pthread_cleanup_pop_restore_np(execute)                               \
608   _pthread_cleanup_pop_restore (&_buffer, (execute)); }
609
610 extern void _pthread_cleanup_pop_restore __P ((struct _pthread_cleanup_buffer *__buffer,
611                                                int __execute));
612
613 /* Functions for handling signals. */
614
615 /* Modify the signal mask for the calling thread.  The arguments have
616    the same meaning as for sigprocmask(2). */
617
618 extern int pthread_sigmask __P ((int __how, __const sigset_t *__newmask,
619                                  sigset_t *__oldmask));
620
621 /* Send signal SIGNO to the given thread. */
622
623 extern int pthread_kill __P ((pthread_t __thread, int __signo));
624
625
626 /* Functions for handling process creation and process execution. */
627
628 /* Install handlers to be called when a new process is created with FORK.
629    The PREPARE handler is called in the parent process just before performing
630    FORK. The PARENT handler is called in the parent process just after FORK.
631    The CHILD handler is called in the child process.  Each of the three
632    handlers can be NULL, meaning that no handler needs to be called at that
633    point.
634    PTHREAD_ATFORK can be called several times, in which case the PREPARE
635    handlers are called in LIFO order (last added with PTHREAD_ATFORK,
636    first called before FORK), and the PARENT and CHILD handlers are called
637    in FIFO (first added, first called). */
638
639 extern int __pthread_atfork __P ((void (*__prepare) (void),
640                                   void (*__parent) (void),
641                                   void (*__child) (void)));
642 extern int pthread_atfork __P ((void (*__prepare) (void),
643                                 void (*__parent) (void),
644                                 void (*__child) (void)));
645
646 /* Terminate all threads in the program except the calling process.
647    Should be called just before invoking one of the exec*() functions. */
648
649 extern void __pthread_kill_other_threads_np __P ((void));
650 extern void pthread_kill_other_threads_np __P ((void));
651
652
653 /* This function is called to initialize the pthread library. */
654 extern void __pthread_initialize __P ((void));
655
656 __END_DECLS
657
658 #endif  /* pthread.h */