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