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