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