1 /* Copyright (C) 2002-2021 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 cancelability 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:
__pthread_cleanup_class(void (* __fct)(void *),void * __arg)576 __pthread_cleanup_class (void (*__fct) (void *), void *__arg)
577 : __cancel_routine (__fct), __cancel_arg (__arg), __do_it (1) { }
~__pthread_cleanup_class()578 ~__pthread_cleanup_class () { if (__do_it) __cancel_routine (__cancel_arg); }
__setdoit(int __newval)579 void __setdoit (int __newval) { __do_it = __newval; }
__defer()580 void __defer () { pthread_setcanceltype (PTHREAD_CANCEL_DEFERRED,
581 &__cancel_type); }
__restore()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
__pthread_cleanup_routine(struct __pthread_cleanup_frame * __frame)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_mutex_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_mutex_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 specfied 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 specfied 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
__NTH(pthread_equal (pthread_t __thread1,pthread_t __thread2))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 */