Warning: This file is not a C or C++ file. It does not have highlighting.
1 | /* Posix threads. Hurd version. |
---|---|
2 | Copyright (C) 2000-2022 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 |
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 |
Warning: This file is not a C or C++ file. It does not have highlighting.