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