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