sysdeps/htl/pthread.h

   1 /* Posix threads.  Hurd version.
   2    Copyright (C) 2000-2024 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library 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 GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library;  if not, see
  17    <https://www.gnu.org/licenses/>.  */
  18
  19 /*
  20  *      POSIX Threads Extension: ???                    <pthread.h>
  21  */
  22
  23 #ifndef _PTHREAD_H
  24 #define _PTHREAD_H      1
  25
  26 #include <features.h>
  27
  28 #include <sys/cdefs.h>
  29 #ifndef __extern_inline
  30 /* GCC 4.3 and above with -std=c99 or -std=gnu99 implements ISO C99
  31    inline semantics, unless -fgnu89-inline is used.  */
  32 # if !defined __cplusplus || __GNUC_PREREQ (4,3)
  33 #  if defined __GNUC_STDC_INLINE__ || defined __cplusplus
  34 #   define __extern_inline extern __inline __attribute__ ((__gnu_inline__))
  35 #   if __GNUC_PREREQ (4,3)
  36 #    define __extern_always_inline \
  37    extern __always_inline __attribute__ ((__gnu_inline__, __artificial__))
  38 #   else
  39 #    define __extern_always_inline \
  40    extern __always_inline __attribute__ ((__gnu_inline__))
  41 #   endif
  42 #  else
  43 #   define __extern_inline extern __inline
  44 #   define __extern_always_inline extern __always_inline
  45 #  endif
  46 # endif
  47 #endif
  48
  49 #include <sched.h>
  50 #include <time.h>
  51
  52 __BEGIN_DECLS
  53
  54 #include <bits/pthreadtypes.h>
  55
  56 #include <bits/pthread.h>
  57
  58 /* Possible values for the process shared attribute.  */
  59 #define PTHREAD_PROCESS_PRIVATE __PTHREAD_PROCESS_PRIVATE
  60 #define PTHREAD_PROCESS_SHARED __PTHREAD_PROCESS_SHARED
  61 \f
  62
  63 /* Thread attributes.  */
  64
  65 /* Possible values for the inheritsched attribute.  */
  66 #define PTHREAD_EXPLICIT_SCHED __PTHREAD_EXPLICIT_SCHED
  67 #define PTHREAD_INHERIT_SCHED __PTHREAD_INHERIT_SCHED
  68
  69 /* Possible values for the `contentionscope' attribute.  */
  70 #define PTHREAD_SCOPE_SYSTEM __PTHREAD_SCOPE_SYSTEM
  71 #define PTHREAD_SCOPE_PROCESS __PTHREAD_SCOPE_PROCESS
  72
  73 /* Possible values for the `detachstate' attribute.  */
  74 #define PTHREAD_CREATE_JOINABLE __PTHREAD_CREATE_JOINABLE
  75 #define PTHREAD_CREATE_DETACHED __PTHREAD_CREATE_DETACHED
  76
  77 #include <bits/types/struct___pthread_attr.h>
  78
  79 /* Initialize the thread attribute object in *ATTR to the default
  80    values.  */
  81 extern int pthread_attr_init (pthread_attr_t *__attr) __THROW __nonnull ((1));
  82
  83 /* Destroy the thread attribute object in *ATTR.  */
  84 extern int pthread_attr_destroy (pthread_attr_t *__attr)
  85         __THROW __nonnull ((1));
  86
  87
  88 /* Return the value of the inheritsched attribute in *ATTR in
  89    *INHERITSCHED.  */
  90 extern int pthread_attr_getinheritsched (const pthread_attr_t *__restrict __attr,
  91                                          int *__restrict __inheritsched)
  92         __THROW __nonnull ((1, 2));
  93
  94 /* Set the value of the inheritsched attribute in *ATTR to
  95    INHERITSCHED.  */
  96 extern int pthread_attr_setinheritsched (pthread_attr_t *__attr,
  97                                          int __inheritsched)
  98         __THROW __nonnull ((1));
  99
 100
 101 /* Return the value of the schedparam attribute in *ATTR in *PARAM.  */
 102 extern int pthread_attr_getschedparam (const pthread_attr_t *__restrict __attr,
 103                                        struct sched_param *__restrict __param)
 104         __THROW __nonnull ((1, 2));
 105
 106 /* Set the value of the schedparam attribute in *ATTR to PARAM.  */
 107 extern int pthread_attr_setschedparam (pthread_attr_t *__restrict __attr,
 108                                        const struct sched_param *__restrict
 109                                        __param) __THROW __nonnull ((1, 2));
 110
 111
 112 /* Return the value of the schedpolicy attribute in *ATTR to *POLICY.  */
 113 extern int pthread_attr_getschedpolicy (const pthread_attr_t *__restrict __attr,
 114                                         int *__restrict __policy)
 115         __THROW __nonnull ((1, 2));
 116
 117 /* Set the value of the schedpolicy attribute in *ATTR to POLICY.  */
 118 extern int pthread_attr_setschedpolicy (pthread_attr_t *__attr,
 119                                         int __policy)
 120         __THROW __nonnull ((1));
 121
 122
 123 /* Return the value of the contentionscope attribute in *ATTR in
 124    *CONTENTIONSCOPE.  */
 125 extern int pthread_attr_getscope (const pthread_attr_t *__restrict __attr,
 126                                   int *__restrict __contentionscope)
 127         __THROW __nonnull ((1, 2));
 128
 129 /* Set the value of the contentionscope attribute in *ATTR to
 130    CONTENTIONSCOPE.  */
 131 extern int pthread_attr_setscope (pthread_attr_t *__attr,
 132                                   int __contentionscope)
 133         __THROW __nonnull ((1));
 134
 135
 136 /* Return the value of the stackaddr attribute in *ATTR in
 137    *STACKADDR.  */
 138 extern int pthread_attr_getstackaddr (const pthread_attr_t *__restrict __attr,
 139                                       void **__restrict __stackaddr)
 140         __THROW __nonnull ((1, 2));
 141
 142 /* Set the value of the stackaddr attribute in *ATTR to STACKADDR.  */
 143 extern int pthread_attr_setstackaddr (pthread_attr_t *__attr,
 144                                       void *__stackaddr)
 145         __THROW __nonnull ((1));
 146
 147
 148 #ifdef __USE_XOPEN2K
 149 /* Return the value of the stackaddr and stacksize attributes in *ATTR
 150    in *STACKADDR and *STACKSIZE respectively.  */
 151 extern int pthread_attr_getstack (const pthread_attr_t *__restrict __attr,
 152                                   void **__restrict __stackaddr,
 153                                   size_t *__restrict __stacksize)
 154         __THROW __nonnull ((1, 2, 3));
 155
 156 /* Set the value of the stackaddr and stacksize attributes in *ATTR to
 157    STACKADDR and STACKSIZE respectively.  */
 158 extern int pthread_attr_setstack (pthread_attr_t *__attr,
 159                                   void *__stackaddr,
 160                                   size_t __stacksize)
 161         __THROW __nonnull ((1));
 162 #endif
 163
 164
 165 /* Return the value of the detachstate attribute in *ATTR in
 166    *DETACHSTATE.  */
 167 extern int pthread_attr_getdetachstate (const pthread_attr_t *__attr,
 168                                         int *__detachstate)
 169         __THROW __nonnull ((1, 2));
 170
 171 /* Set the value of the detachstate attribute in *ATTR to
 172    DETACHSTATE.  */
 173 extern int pthread_attr_setdetachstate (pthread_attr_t *__attr,
 174                                         int __detachstate)
 175         __THROW __nonnull ((1));
 176
 177
 178 /* Return the value of the guardsize attribute in *ATTR in
 179    *GUARDSIZE.  */
 180 extern int pthread_attr_getguardsize (const pthread_attr_t *__restrict __attr,
 181                                       size_t *__restrict __guardsize)
 182         __THROW __nonnull ((1, 2));
 183
 184 /* Set the value of the guardsize attribute in *ATTR to GUARDSIZE.  */
 185 extern int pthread_attr_setguardsize (pthread_attr_t *__attr,
 186                                       size_t __guardsize)
 187         __THROW __nonnull ((1));
 188
 189
 190 /* Return the value of the stacksize attribute in *ATTR in
 191    *STACKSIZE.  */
 192 extern int pthread_attr_getstacksize (const pthread_attr_t *__restrict __attr,
 193                                       size_t *__restrict __stacksize)
 194         __THROW __nonnull ((1, 2));
 195
 196 /* Set the value of the stacksize attribute in *ATTR to STACKSIZE.  */
 197 extern int pthread_attr_setstacksize (pthread_attr_t *__attr,
 198                                       size_t __stacksize)
 199         __THROW __nonnull ((1));
 200
 201 #ifdef __USE_GNU
 202 /* Initialize thread attribute *ATTR with attributes corresponding to the
 203    already running thread THREAD.  It shall be called on an uninitialized ATTR
 204    and destroyed with pthread_attr_destroy when no longer needed.  */
 205 extern int pthread_getattr_np (pthread_t __thr, pthread_attr_t *__attr)
 206         __THROW __nonnull ((2));
 207 #endif
 208 \f
 209
 210 /* Create a thread with attributes given by ATTR, executing
 211    START_ROUTINE with argument ARG.  */
 212 extern int pthread_create (pthread_t *__restrict __threadp,
 213                            __const pthread_attr_t *__restrict __attr,
 214                            void *(*__start_routine)(void *),
 215                            void *__restrict __arg) __THROWNL __nonnull ((1, 3));
 216
 217 /* Terminate the current thread and make STATUS available to any
 218    thread that might join us.  */
 219 extern void pthread_exit (void *__status) __attribute__ ((__noreturn__));
 220
 221 /* Make calling thread wait for termination of thread THREAD.  Return
 222    the exit status of the thread in *STATUS.  */
 223 extern int pthread_join (pthread_t __threadp, void **__status);
 224
 225 #ifdef __USE_GNU
 226 /* Check whether thread TH has terminated.  If yes return the status of
 227    the thread in *THREAD_RETURN, if THREAD_RETURN is not NULL.  */
 228 extern int pthread_tryjoin_np (pthread_t __th, void **__thread_return) __THROW;
 229
 230 /* Make calling thread wait for termination of the thread TH, but only
 231    until TIMEOUT.  The exit status of the thread is stored in
 232    *THREAD_RETURN, if THREAD_RETURN is not NULL.
 233
 234    This function is a cancellation point and therefore not marked with
 235    __THROW.  */
 236 extern int pthread_timedjoin_np (pthread_t __th, void **__thread_return,
 237                                  const struct timespec *__abstime);
 238
 239 /* Make calling thread wait for termination of the thread TH, but only
 240    until TIMEOUT measured against the clock specified by CLOCKID.  The
 241    exit status of the thread is stored in *THREAD_RETURN, if
 242    THREAD_RETURN is not NULL.
 243
 244    This function is a cancellation point and therefore not marked with
 245    __THROW.  */
 246 extern int pthread_clockjoin_np (pthread_t __th, void **__thread_return,
 247                                  clockid_t __clockid,
 248                                  const struct timespec *__abstime);
 249 #endif
 250
 251 /* Indicate that the storage for THREAD can be reclaimed when it
 252    terminates.  */
 253 extern int pthread_detach (pthread_t __threadp);
 254
 255 /* Compare thread IDs T1 and T2.  Return nonzero if they are equal, 0
 256    if they are not.  */
 257 extern int pthread_equal (pthread_t __t1, pthread_t __t2);
 258
 259 #ifdef __USE_EXTERN_INLINES
 260
 261 __extern_inline int
 262 pthread_equal (pthread_t __t1, pthread_t __t2)
 263 {
 264   return __pthread_equal (__t1, __t2);
 265 }
 266
 267 #endif /* Use extern inlines.  */
 268
 269
 270 /* Return the thread ID of the calling thread.  */
 271 extern pthread_t pthread_self (void) __THROW;
 272 \f
 273
 274 /* Mutex attributes.  */
 275
 276 #define PTHREAD_PRIO_NONE_NP __PTHREAD_PRIO_NONE
 277 #define PTHREAD_PRIO_INHERIT_NP __PTHREAD_PRIO_INHERIT
 278 #define PTHREAD_PRIO_PROTECT_NP __PTHREAD_PRIO_PROTECT
 279 #ifdef __USE_UNIX98
 280 # define PTHREAD_PRIO_NONE PTHREAD_PRIO_NONE_NP
 281 # define PTHREAD_PRIO_INHERIT PTHREAD_PRIO_INHERIT_NP
 282 # define PTHREAD_PRIO_PROTECT PTHREAD_PRIO_PROTECT_NP
 283 #endif
 284
 285 #define PTHREAD_MUTEX_TIMED_NP __PTHREAD_MUTEX_TIMED
 286 #define PTHREAD_MUTEX_ERRORCHECK_NP __PTHREAD_MUTEX_ERRORCHECK
 287 #define PTHREAD_MUTEX_RECURSIVE_NP __PTHREAD_MUTEX_RECURSIVE
 288 #if defined __USE_UNIX98 || defined __USE_XOPEN2K8
 289 # define PTHREAD_MUTEX_NORMAL PTHREAD_MUTEX_TIMED_NP
 290 # define PTHREAD_MUTEX_ERRORCHECK PTHREAD_MUTEX_ERRORCHECK_NP
 291 # define PTHREAD_MUTEX_RECURSIVE PTHREAD_MUTEX_RECURSIVE_NP
 292 # define PTHREAD_MUTEX_DEFAULT PTHREAD_MUTEX_NORMAL
 293 #endif
 294 #ifdef __USE_GNU
 295 /* For compatibility.  */
 296 # define PTHREAD_MUTEX_FAST_NP PTHREAD_MUTEX_TIMED_NP
 297 #endif
 298
 299 #ifdef __USE_XOPEN2K
 300 # define PTHREAD_MUTEX_STALLED __PTHREAD_MUTEX_STALLED
 301 # define PTHREAD_MUTEX_ROBUST __PTHREAD_MUTEX_ROBUST
 302 # define PTHREAD_MUTEX_ROBUST_NP __PTHREAD_MUTEX_ROBUST
 303 #endif
 304
 305 #include <bits/types/struct___pthread_mutexattr.h>
 306
 307 /* Initialize the mutex attribute object in *ATTR to the default
 308    values.  */
 309 extern int pthread_mutexattr_init(pthread_mutexattr_t *__attr)
 310         __THROW __nonnull ((1));
 311
 312 /* Destroy the mutex attribute structure in *ATTR.  */
 313 extern int pthread_mutexattr_destroy(pthread_mutexattr_t *__attr)
 314         __THROW __nonnull ((1));
 315
 316
 317 #ifdef __USE_UNIX98
 318 /* Return the value of the prioceiling attribute in *ATTR in
 319    *PRIOCEILING.  */
 320 extern int pthread_mutexattr_getprioceiling(const pthread_mutexattr_t *__restrict __attr,
 321                                             int *__restrict __prioceiling)
 322         __THROW __nonnull ((1, 2));
 323
 324 /* Set the value of the prioceiling attribute in *ATTR to
 325    PRIOCEILING.  */
 326 extern int pthread_mutexattr_setprioceiling(pthread_mutexattr_t *__attr,
 327                                             int __prioceiling)
 328         __THROW __nonnull ((1));
 329
 330
 331 /* Return the value of the protocol attribute in *ATTR in
 332    *PROTOCOL.  */
 333 extern int pthread_mutexattr_getprotocol(const pthread_mutexattr_t *__restrict __attr,
 334                                          int *__restrict __protocol)
 335         __THROW __nonnull ((1, 2));
 336
 337 /* Set the value of the protocol attribute in *ATTR to PROTOCOL.  */
 338 extern int pthread_mutexattr_setprotocol(pthread_mutexattr_t *__attr,
 339                                          int __protocol)
 340         __THROW __nonnull ((1));
 341 #endif
 342
 343 #ifdef __USE_XOPEN2K
 344 /* Get the robustness flag of the mutex attribute ATTR.  */
 345 extern int pthread_mutexattr_getrobust (const pthread_mutexattr_t *__attr,
 346                                         int *__robustness)
 347      __THROW __nonnull ((1, 2));
 348 # ifdef __USE_GNU
 349 extern int pthread_mutexattr_getrobust_np (const pthread_mutexattr_t *__attr,
 350                                            int *__robustness)
 351      __THROW __nonnull ((1, 2));
 352 # endif
 353
 354 /* Set the robustness flag of the mutex attribute ATTR.  */
 355 extern int pthread_mutexattr_setrobust (pthread_mutexattr_t *__attr,
 356                                         int __robustness)
 357      __THROW __nonnull ((1));
 358 # ifdef __USE_GNU
 359 extern int pthread_mutexattr_setrobust_np (pthread_mutexattr_t *__attr,
 360                                            int __robustness)
 361      __THROW __nonnull ((1));
 362 # endif
 363 #endif
 364
 365
 366 /* Return the value of the process shared attribute in *ATTR in
 367    *PSHARED.  */
 368 extern int pthread_mutexattr_getpshared(const pthread_mutexattr_t *__restrict __attr,
 369                                         int *__restrict __pshared)
 370         __THROW __nonnull ((1, 2));
 371
 372 /* Set the value of the process shared attribute in *ATTR to
 373    PSHARED.  */
 374 extern int pthread_mutexattr_setpshared(pthread_mutexattr_t *__attr,
 375                                         int __pshared)
 376         __THROW __nonnull ((1));
 377
 378
 379 #if defined __USE_UNIX98 || defined __USE_XOPEN2K8
 380 /* Return the value of the type attribute in *ATTR in *TYPE.  */
 381 extern int pthread_mutexattr_gettype(const pthread_mutexattr_t *__restrict __attr,
 382                                      int *__restrict __type)
 383         __THROW __nonnull ((1, 2));
 384
 385 /* Set the value of the type attribute in *ATTR to TYPE.  */
 386 extern int pthread_mutexattr_settype(pthread_mutexattr_t *__attr,
 387                                      int __type)
 388         __THROW __nonnull ((1));
 389 #endif
 390 \f
 391
 392 /* Mutexes.  */
 393
 394 #include <bits/types/struct___pthread_mutex.h>
 395
 396 #define PTHREAD_MUTEX_INITIALIZER __PTHREAD_MUTEX_INITIALIZER
 397 /* Static initializer for recursive mutexes.  */
 398
 399 #ifdef __USE_GNU
 400 # define PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP \
 401   __PTHREAD_ERRORCHECK_MUTEX_INITIALIZER
 402 # define PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP \
 403   __PTHREAD_RECURSIVE_MUTEX_INITIALIZER
 404 #endif
 405
 406 /* Create a mutex with attributes given by ATTR and store it in
 407    *__MUTEX.  */
 408 extern int pthread_mutex_init (struct __pthread_mutex *__restrict __mutex,
 409                                const pthread_mutexattr_t *__restrict __attr)
 410         __THROW __nonnull ((1));
 411
 412 /* Destroy the mutex __MUTEX.  */
 413 extern int pthread_mutex_destroy (struct __pthread_mutex *__mutex)
 414         __THROW __nonnull ((1));
 415
 416 /* Wait until lock for MUTEX becomes available and lock it.  */
 417 extern int pthread_mutex_lock (pthread_mutex_t *__mutex);
 418
 419 /* Try to lock MUTEX.  */
 420 extern int pthread_mutex_trylock (pthread_mutex_t *__mutex)
 421         __THROWNL __nonnull ((1));
 422
 423 #ifdef __USE_XOPEN2K
 424 /* Try to lock MUTEX, block until *ABSTIME if it is already held.  */
 425 extern int pthread_mutex_timedlock (struct __pthread_mutex *__restrict __mutex,
 426                                     const struct timespec *__restrict __abstime)
 427         __THROWNL __nonnull ((1, 2));
 428 #endif
 429
 430 #ifdef __USE_GNU
 431 extern int pthread_mutex_clocklock (pthread_mutex_t *__restrict __mutex,
 432                                     clockid_t __clockid,
 433                                     const struct timespec *__restrict
 434                                     __abstime) __THROWNL __nonnull ((1, 3));
 435 #endif
 436
 437 /* Unlock MUTEX.  */
 438 extern int pthread_mutex_unlock (pthread_mutex_t *__mutex)
 439         __THROWNL __nonnull ((1));
 440
 441 /* Transfer ownership of the mutex MUTEX to the thread TID.  The
 442    caller must own the lock.  */
 443 extern int __pthread_mutex_transfer_np (struct __pthread_mutex *__mutex,
 444                                         pthread_t __tid)
 445         __THROWNL __nonnull ((1));
 446
 447
 448 #ifdef __USE_UNIX98
 449 /* Return the priority ceiling of mutex *MUTEX in *PRIOCEILING.  */
 450 extern int pthread_mutex_getprioceiling (const pthread_mutex_t *__restrict __mutex,
 451                                          int *__restrict __prioceiling)
 452         __THROW __nonnull ((1, 2));
 453
 454 /* After acquiring the mutex *MUTEX, set its priority ceiling to PRIO
 455    and return the old priority ceiling in *OLDPRIO.  Before returning,
 456    release the mutex.  */
 457 extern int pthread_mutex_setprioceiling (pthread_mutex_t *__restrict __mutex,
 458                                          int __prio, int *__restrict __oldprio)
 459         __THROW __nonnull ((1, 3));
 460 #endif
 461
 462 #ifdef __USE_XOPEN2K8
 463
 464 /* Declare the state protected by robust mutex MTXP as consistent. */
 465 extern int pthread_mutex_consistent (pthread_mutex_t *__mtxp)
 466   __THROW __nonnull ((1));
 467
 468 #  ifdef __USE_GNU
 469 extern int pthread_mutex_consistent_np (pthread_mutex_t *__mtxp)
 470   __THROW __nonnull ((1));
 471 #  endif
 472 #endif
 473
 474 \f
 475
 476 /* Condition attributes.  */
 477
 478 #include <bits/types/struct___pthread_condattr.h>
 479
 480 /* Initialize the condition attribute in *ATTR to the default
 481    values.  */
 482 extern int pthread_condattr_init (pthread_condattr_t *__attr)
 483         __THROW __nonnull ((1));
 484
 485 /* Destroy the condition attribute structure in *ATTR.  */
 486 extern int pthread_condattr_destroy (pthread_condattr_t *__attr)
 487         __THROW __nonnull ((1));
 488
 489
 490 #ifdef __USE_XOPEN2K
 491 /* Return the value of the clock attribute in *ATTR in *CLOCK_ID.  */
 492 extern int pthread_condattr_getclock (const pthread_condattr_t *__restrict __attr,
 493                                       __clockid_t *__restrict __clock_id)
 494         __THROW __nonnull ((1, 2));
 495
 496 /* Set the value of the clock attribute in *ATTR to CLOCK_ID.  */
 497 extern int pthread_condattr_setclock (pthread_condattr_t *__attr,
 498                                       __clockid_t __clock_id)
 499         __THROW __nonnull ((1));
 500 #endif
 501
 502
 503 /* Return the value of the process shared attribute in *ATTR in
 504    *PSHARED.  */
 505 extern int pthread_condattr_getpshared (const pthread_condattr_t *__restrict __attr,
 506                                         int *__restrict __pshared)
 507         __THROW __nonnull ((1, 2));
 508
 509 /* Set the value of the process shared attribute in *ATTR to
 510    PSHARED.  */
 511 extern int pthread_condattr_setpshared (pthread_condattr_t *__attr,
 512                                         int __pshared)
 513         __THROW __nonnull ((1));
 514 \f
 515
 516 /* Condition variables.  */
 517
 518 #include <bits/types/struct___pthread_cond.h>
 519
 520 #define PTHREAD_COND_INITIALIZER __PTHREAD_COND_INITIALIZER
 521
 522 extern int pthread_cond_init (pthread_cond_t *__restrict __cond,
 523                               const pthread_condattr_t *__restrict __attr)
 524         __THROW __nonnull ((1));
 525
 526 extern int pthread_cond_destroy (pthread_cond_t *__cond)
 527         __THROW __nonnull ((1));
 528
 529 /* Unblock at least one of the threads that are blocked on condition
 530    variable COND.  */
 531 extern int pthread_cond_signal (pthread_cond_t *__cond)
 532         __THROWNL __nonnull ((1));
 533
 534 /* Unblock all threads that are blocked on condition variable COND.  */
 535 extern int pthread_cond_broadcast (pthread_cond_t *__cond)
 536         __THROWNL __nonnull ((1));
 537
 538 /* Block on condition variable COND.  MUTEX should be held by the
 539    calling thread.  On success, MUTEX will be held by the calling
 540    thread.  */
 541 extern int pthread_cond_wait (pthread_cond_t *__restrict __cond,
 542                               pthread_mutex_t *__restrict __mutex)
 543          __nonnull ((1, 2));
 544
 545 /* Block on condition variable COND.  MUTEX should be held by the
 546    calling thread. On success, MUTEX will be held by the calling
 547    thread.  If the time specified by ABSTIME passes, ETIMEDOUT is
 548    returned, and MUTEX will nevertheless be held.  */
 549 extern int pthread_cond_timedwait (pthread_cond_t *__restrict __cond,
 550                                    pthread_mutex_t *__restrict __mutex,
 551                                    __const struct timespec *__restrict __abstime)
 552          __nonnull ((1, 2, 3));
 553
 554 # ifdef __USE_GNU
 555 /* Wait for condition variable COND to be signaled or broadcast until
 556    ABSTIME measured by the specified clock. MUTEX is assumed to be
 557    locked before. CLOCK is the clock to use. ABSTIME is an absolute
 558    time specification against CLOCK's epoch.
 559
 560    This function is a cancellation point and therefore not marked with
 561    __THROW. */
 562 extern int pthread_cond_clockwait (pthread_cond_t *__restrict __cond,
 563                                    pthread_mutex_t *__restrict __mutex,
 564                                    __clockid_t __clock_id,
 565                                    const struct timespec *__restrict __abstime)
 566      __nonnull ((1, 2, 4));
 567 # endif
 568 \f
 569
 570 /* Spin locks.  */
 571
 572 #ifdef __USE_XOPEN2K
 573
 574 # include <bits/types/__pthread_spinlock_t.h>
 575
 576 # define PTHREAD_SPINLOCK_INITIALIZER __PTHREAD_SPIN_LOCK_INITIALIZER
 577
 578 /* Destroy the spin lock object LOCK.  */
 579 extern int pthread_spin_destroy (pthread_spinlock_t *__lock)
 580         __nonnull ((1));
 581
 582 /* Initialize the spin lock object LOCK.  PSHARED determines whether
 583    the spin lock can be operated upon by multiple processes.  */
 584 extern int pthread_spin_init (pthread_spinlock_t *__lock, int __pshared)
 585         __nonnull ((1));
 586
 587 /* Lock the spin lock object LOCK.  If the lock is held by another
 588    thread spin until it becomes available.  */
 589 extern int pthread_spin_lock (pthread_spinlock_t *__lock)
 590         __nonnull ((1));
 591
 592 /* Lock the spin lock object LOCK.  Fail if the lock is held by
 593    another thread.  */
 594 extern int pthread_spin_trylock (pthread_spinlock_t *__lock)
 595         __nonnull ((1));
 596
 597 /* Unlock the spin lock object LOCK.  */
 598 extern int pthread_spin_unlock (pthread_spinlock_t *__lock)
 599         __nonnull ((1));
 600
 601 #endif /* XPG6.  */
 602 \f
 603
 604 /* rwlock attributes.  */
 605
 606 #if defined __USE_UNIX98 || defined __USE_XOPEN2K
 607
 608 # include <bits/types/struct___pthread_rwlockattr.h>
 609
 610 /* Initialize rwlock attribute object in *ATTR to the default
 611    values.  */
 612 extern int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr)
 613         __THROW __nonnull ((1));
 614
 615 /* Destroy the rwlock attribute object in *ATTR.  */
 616 extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr)
 617         __THROW __nonnull ((1));
 618
 619
 620 /* Return the value of the process shared attribute in *ATTR in
 621    *PSHARED.  */
 622 extern int pthread_rwlockattr_getpshared (const pthread_rwlockattr_t *__restrict __attr,
 623                                           int *__restrict __pshared)
 624         __THROW __nonnull ((1, 2));
 625
 626 /* Set the value of the process shared attribute in *ATTR to
 627    PSHARED.  */
 628 extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr,
 629                                           int __pshared)
 630         __THROW __nonnull ((1));
 631
 632 /* Return current setting of reader/writer preference.  */
 633 extern int pthread_rwlockattr_getkind_np (const pthread_rwlockattr_t *
 634                                           __restrict __attr,
 635                                           int *__restrict __pref)
 636      __THROW __nonnull ((1, 2));
 637
 638 /* Set reader/write preference.  */
 639 extern int pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *__attr,
 640                                           int __pref) __THROW __nonnull ((1));
 641 \f
 642
 643 /* rwlocks.  */
 644
 645 # include <bits/types/struct___pthread_rwlock.h>
 646
 647 # define PTHREAD_RWLOCK_INITIALIZER __PTHREAD_RWLOCK_INITIALIZER
 648 /* Create a rwlock object with attributes given by ATTR and store the
 649    result in *RWLOCK.  */
 650 extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock,
 651                                 const pthread_rwlockattr_t *__restrict __attr)
 652         __THROW __nonnull ((1));
 653
 654 /* Destroy the rwlock *RWLOCK.  */
 655 extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock)
 656         __THROW __nonnull ((1));
 657
 658 /* Acquire the rwlock *RWLOCK for reading.  */
 659 extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock)
 660         __THROWNL __nonnull ((1));
 661
 662 /* Acquire the rwlock *RWLOCK for reading.  */
 663 extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock)
 664         __THROWNL __nonnull ((1));
 665
 666 # ifdef __USE_XOPEN2K
 667 /* Acquire the rwlock *RWLOCK for reading blocking until *ABSTIME if
 668    it is already held.  */
 669 extern int pthread_rwlock_timedrdlock (struct __pthread_rwlock *__restrict __rwlock,
 670                                        const struct timespec *__restrict __abstime)
 671         __THROWNL __nonnull ((1, 2));
 672 # endif
 673
 674 # ifdef __USE_GNU
 675 extern int pthread_rwlock_clockrdlock (pthread_rwlock_t *__restrict __rwlock,
 676                                        clockid_t __clockid,
 677                                        const struct timespec *__restrict
 678                                        __abstime) __THROWNL __nonnull ((1, 3));
 679 # endif
 680
 681 /* Acquire the rwlock *RWLOCK for writing.  */
 682 extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock)
 683         __THROWNL __nonnull ((1));
 684
 685 /* Try to acquire the rwlock *RWLOCK for writing.  */
 686 extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock)
 687         __THROWNL __nonnull ((1));
 688
 689 # ifdef __USE_XOPEN2K
 690 /* Acquire the rwlock *RWLOCK for writing blocking until *ABSTIME if
 691    it is already held.  */
 692 extern int pthread_rwlock_timedwrlock (struct __pthread_rwlock *__restrict __rwlock,
 693                                        const struct timespec *__restrict __abstime)
 694         __THROWNL __nonnull ((1, 2));
 695 # endif
 696
 697 # ifdef __USE_GNU
 698 extern int pthread_rwlock_clockwrlock (pthread_rwlock_t *__restrict __rwlock,
 699                                        clockid_t __clockid,
 700                                        const struct timespec *__restrict
 701                                        __abstime) __THROWNL __nonnull ((1, 3));
 702 # endif
 703
 704 /* Release the lock held by the current thread on *RWLOCK.  */
 705 extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock)
 706         __THROWNL __nonnull ((1));
 707
 708 #endif /* __USE_UNIX98 || __USE_XOPEN2K */
 709
 710 \f
 711
 712 /* Cancellation.  */
 713
 714 /* Register a cleanup handler.  */
 715 extern void pthread_cleanup_push (void (*__routine) (void *), void *__arg);
 716
 717 /* Unregister a cleanup handler.  */
 718 extern void pthread_cleanup_pop (int __execute);
 719
 720 #include <bits/cancelation.h>
 721
 722 #define pthread_cleanup_push(rt, rtarg) __pthread_cleanup_push(rt, rtarg)
 723 #define pthread_cleanup_pop(execute) __pthread_cleanup_pop(execute)
 724
 725 #define PTHREAD_CANCEL_DISABLE 0
 726 #define PTHREAD_CANCEL_ENABLE 1
 727
 728 /* Return the calling thread's cancelation state in *OLDSTATE and set
 729    its state to STATE.  */
 730 extern int pthread_setcancelstate (int __state, int *__oldstate);
 731
 732 #define PTHREAD_CANCEL_DEFERRED 0
 733 #define PTHREAD_CANCEL_ASYNCHRONOUS 1
 734
 735 /* Return the calling thread's cancelation type in *OLDTYPE and set
 736    its type to TYPE.  */
 737 extern int pthread_setcanceltype (int __type, int *__oldtype);
 738
 739 /* Value returned by pthread_join if the target thread was
 740    canceled.  */
 741 #define PTHREAD_CANCELED ((void *) -1)
 742
 743 /* Cancel THEAD.  */
 744 extern int pthread_cancel (pthread_t __thr);
 745
 746 /* Add an explicit cancelation point.  */
 747 extern void pthread_testcancel (void);
 748 \f
 749
 750 /* Barriers attributes.  */
 751
 752 #ifdef __USE_XOPEN2K
 753
 754 # include <bits/types/struct___pthread_barrierattr.h>
 755
 756 /* Initialize barrier attribute object in *ATTR to the default
 757    values.  */
 758 extern int pthread_barrierattr_init (pthread_barrierattr_t *__attr)
 759         __THROW __nonnull ((1));
 760
 761 /* Destroy the barrier attribute object in *ATTR.  */
 762 extern int pthread_barrierattr_destroy (pthread_barrierattr_t *__attr)
 763         __THROW __nonnull ((1));
 764
 765
 766 /* Return the value of the process shared attribute in *ATTR in
 767    *PSHARED.  */
 768 extern int pthread_barrierattr_getpshared (const pthread_barrierattr_t *__restrict __attr,
 769                                            int *__restrict __pshared)
 770         __THROW __nonnull ((1, 2));
 771
 772 /* Set the value of the process shared attribute in *ATTR to
 773    PSHARED.  */
 774 extern int pthread_barrierattr_setpshared (pthread_barrierattr_t *__attr,
 775                                            int __pshared)
 776         __THROW __nonnull ((1));
 777 \f
 778
 779 /* Barriers.  */
 780
 781 # include <bits/types/struct___pthread_barrier.h>
 782
 783 /* Returned by pthread_barrier_wait to exactly one thread each time a
 784    barrier is passed.  */
 785 # define PTHREAD_BARRIER_SERIAL_THREAD -1
 786
 787 /* Initialize barrier BARRIER.  */
 788 extern int pthread_barrier_init (pthread_barrier_t *__restrict __barrier,
 789                                 const pthread_barrierattr_t *__restrict __attr,
 790                                 unsigned __count)
 791         __THROW __nonnull ((1));
 792
 793 /* Destroy barrier BARRIER.  */
 794 extern int pthread_barrier_destroy (pthread_barrier_t *__barrier)
 795         __THROW __nonnull ((1));
 796
 797 /* Wait on barrier BARRIER.  */
 798 extern int pthread_barrier_wait (pthread_barrier_t *__barrier)
 799         __THROWNL __nonnull ((1));
 800
 801 #endif /* __USE_XOPEN2K */
 802
 803 \f
 804
 805 /* Thread specific data.  */
 806
 807 #include <bits/types/__pthread_key.h>
 808
 809 /* Create a thread specific data key in KEY visible to all threads.
 810    On thread destruction, DESTRUCTOR shall be called with the thread
 811    specific data associate with KEY if it is not NULL.  */
 812 extern int pthread_key_create (pthread_key_t *__key,
 813                                void (*__destructor) (void *))
 814         __THROW __nonnull ((1));
 815
 816 /* Delete the thread specific data key KEY.  The associated destructor
 817    function is not called.  */
 818 extern int pthread_key_delete (pthread_key_t __key) __THROW;
 819
 820 /* Return the caller thread's thread specific value of KEY.  */
 821 extern void *pthread_getspecific (pthread_key_t __key) __THROW;
 822
 823 /* Set the caller thread's thread specific value of KEY to VALUE.  */
 824 extern int pthread_setspecific (pthread_key_t __key, const void *__value)
 825         __THROW __attr_access_none (2);
 826 \f
 827
 828 /* Dynamic package initialization.  */
 829
 830 #include <bits/types/struct___pthread_once.h>
 831
 832 #define PTHREAD_ONCE_INIT (struct __pthread_once) { __PTHREAD_ONCE_INIT }
 833
 834 /* Call INIT_ROUTINE if this function has never been called with
 835    *ONCE_CONTROL, otherwise do nothing.  */
 836 extern int pthread_once (pthread_once_t *__once_control,
 837                          void (*__init_routine) (void)) __nonnull ((1, 2));
 838 \f
 839
 840 /* Concurrency.  */
 841
 842 #ifdef __USE_UNIX98
 843 /* Set the desired concurrency level to NEW_LEVEL.  */
 844 extern int pthread_setconcurrency (int __new_level) __THROW;
 845
 846 /* Get the current concurrency level.  */
 847 extern int pthread_getconcurrency (void) __THROW;
 848 #endif
 849 \f
 850
 851 /* Forking.  */
 852
 853 /* Register the function PREPARE to be run before the process forks,
 854    the function PARENT to be run after a fork in the parent and the
 855    function CHILD to be run in the child after the fork.  If no
 856    handling is desired then any of PREPARE, PARENT and CHILD may be
 857    NULL.  The prepare handles will be called in the reverse order
 858    which they were registered and the parent and child handlers in the
 859    order in which they were registered.  */
 860 extern int pthread_atfork (void (*__prepare) (void), void (*__parent) (void),
 861                            void (*__child) (void)) __THROW;
 862 \f
 863
 864 /* Signals (should be in <signal.h>).  */
 865
 866 /* Send signal SIGNO to thread THREAD.  */
 867 extern int pthread_kill (pthread_t __thr, int __signo) __THROW;
 868 \f
 869
 870 /* Time.  */
 871
 872 #ifdef __USE_XOPEN2K
 873 /* Return the thread cpu clock.  */
 874 extern int pthread_getcpuclockid (pthread_t __thr, __clockid_t *__clock)
 875         __THROW __nonnull ((2));
 876 #endif
 877 \f
 878
 879 /* Scheduling.  */
 880
 881 /* Return thread THREAD's scheduling parameters.  */
 882 extern int pthread_getschedparam (pthread_t __thr, int *__restrict __policy,
 883                                   struct sched_param *__restrict __param)
 884         __THROW __nonnull ((2, 3));
 885
 886 /* Set thread THREAD's scheduling parameters.  */
 887 extern int pthread_setschedparam (pthread_t __thr, int __policy,
 888                                   const struct sched_param *__param)
 889         __THROW __nonnull ((3));
 890
 891 /* Set thread THREAD's scheduling priority.  */
 892 extern int pthread_setschedprio (pthread_t __thr, int __prio) __THROW;
 893
 894 #ifdef __USE_GNU
 895 /* Get thread name visible in the kernel and its interfaces.  */
 896 extern int pthread_getname_np (pthread_t __target_thread, char *__buf,
 897                                size_t __buflen)
 898      __THROW __nonnull ((2)) __attr_access ((__write_only__, 2));
 899
 900 /* Set thread name visible in the kernel and its interfaces.  */
 901 extern int pthread_setname_np (pthread_t __target_thread, const char *__name)
 902      __THROW __nonnull ((2)) __attr_access ((__read_only__, 2));
 903 #endif
 904
 905 #ifdef __USE_GNU
 906 /* Yield the processor to another thread or process.
 907    This function is similar to the POSIX `sched_yield' function but
 908    might be differently implemented in the case of a m-on-n thread
 909    implementation.  */
 910 extern int pthread_yield (void) __THROW;
 911 #endif
 912 \f
 913
 914 /* Kernel-specific interfaces.  */
 915
 916 #include <bits/pthread-np.h>
 917
 918
 919 __END_DECLS
 920
 921 #endif /* pthread.h */