1 | /* Copyright (C) 2002-2018 Free Software Foundation, Inc. |
2 | This file is part of the GNU C Library. |
3 | Contributed by Ulrich Drepper <drepper@redhat.com>, 2002. |
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 | <http://www.gnu.org/licenses/>. */ |
18 | |
19 | #ifndef _PTHREADP_H |
20 | #define _PTHREADP_H 1 |
21 | |
22 | #include <pthread.h> |
23 | #include <setjmp.h> |
24 | #include <stdbool.h> |
25 | #include <sys/syscall.h> |
26 | #include "descr.h" |
27 | #include <tls.h> |
28 | #include <lowlevellock.h> |
29 | #include <stackinfo.h> |
30 | #include <internaltypes.h> |
31 | #include <pthread-functions.h> |
32 | #include <atomic.h> |
33 | #include <kernel-features.h> |
34 | #include <errno.h> |
35 | #include <nptl-signals.h> |
36 | |
37 | |
38 | /* Atomic operations on TLS memory. */ |
39 | #ifndef THREAD_ATOMIC_CMPXCHG_VAL |
40 | # define THREAD_ATOMIC_CMPXCHG_VAL(descr, member, new, old) \ |
41 | atomic_compare_and_exchange_val_acq (&(descr)->member, new, old) |
42 | #endif |
43 | |
44 | #ifndef THREAD_ATOMIC_BIT_SET |
45 | # define THREAD_ATOMIC_BIT_SET(descr, member, bit) \ |
46 | atomic_bit_set (&(descr)->member, bit) |
47 | #endif |
48 | |
49 | |
50 | /* Adaptive mutex definitions. */ |
51 | #ifndef MAX_ADAPTIVE_COUNT |
52 | # define MAX_ADAPTIVE_COUNT 100 |
53 | #endif |
54 | |
55 | |
56 | /* Magic cookie representing robust mutex with dead owner. */ |
57 | #define PTHREAD_MUTEX_INCONSISTENT INT_MAX |
58 | /* Magic cookie representing not recoverable robust mutex. */ |
59 | #define PTHREAD_MUTEX_NOTRECOVERABLE (INT_MAX - 1) |
60 | |
61 | |
62 | /* Internal mutex type value. */ |
63 | enum |
64 | { |
65 | PTHREAD_MUTEX_KIND_MASK_NP = 3, |
66 | |
67 | PTHREAD_MUTEX_ELISION_NP = 256, |
68 | PTHREAD_MUTEX_NO_ELISION_NP = 512, |
69 | |
70 | PTHREAD_MUTEX_ROBUST_NORMAL_NP = 16, |
71 | PTHREAD_MUTEX_ROBUST_RECURSIVE_NP |
72 | = PTHREAD_MUTEX_ROBUST_NORMAL_NP | PTHREAD_MUTEX_RECURSIVE_NP, |
73 | PTHREAD_MUTEX_ROBUST_ERRORCHECK_NP |
74 | = PTHREAD_MUTEX_ROBUST_NORMAL_NP | PTHREAD_MUTEX_ERRORCHECK_NP, |
75 | PTHREAD_MUTEX_ROBUST_ADAPTIVE_NP |
76 | = PTHREAD_MUTEX_ROBUST_NORMAL_NP | PTHREAD_MUTEX_ADAPTIVE_NP, |
77 | PTHREAD_MUTEX_PRIO_INHERIT_NP = 32, |
78 | PTHREAD_MUTEX_PI_NORMAL_NP |
79 | = PTHREAD_MUTEX_PRIO_INHERIT_NP | PTHREAD_MUTEX_NORMAL, |
80 | PTHREAD_MUTEX_PI_RECURSIVE_NP |
81 | = PTHREAD_MUTEX_PRIO_INHERIT_NP | PTHREAD_MUTEX_RECURSIVE_NP, |
82 | PTHREAD_MUTEX_PI_ERRORCHECK_NP |
83 | = PTHREAD_MUTEX_PRIO_INHERIT_NP | PTHREAD_MUTEX_ERRORCHECK_NP, |
84 | PTHREAD_MUTEX_PI_ADAPTIVE_NP |
85 | = PTHREAD_MUTEX_PRIO_INHERIT_NP | PTHREAD_MUTEX_ADAPTIVE_NP, |
86 | PTHREAD_MUTEX_PI_ROBUST_NORMAL_NP |
87 | = PTHREAD_MUTEX_PRIO_INHERIT_NP | PTHREAD_MUTEX_ROBUST_NORMAL_NP, |
88 | PTHREAD_MUTEX_PI_ROBUST_RECURSIVE_NP |
89 | = PTHREAD_MUTEX_PRIO_INHERIT_NP | PTHREAD_MUTEX_ROBUST_RECURSIVE_NP, |
90 | PTHREAD_MUTEX_PI_ROBUST_ERRORCHECK_NP |
91 | = PTHREAD_MUTEX_PRIO_INHERIT_NP | PTHREAD_MUTEX_ROBUST_ERRORCHECK_NP, |
92 | PTHREAD_MUTEX_PI_ROBUST_ADAPTIVE_NP |
93 | = PTHREAD_MUTEX_PRIO_INHERIT_NP | PTHREAD_MUTEX_ROBUST_ADAPTIVE_NP, |
94 | PTHREAD_MUTEX_PRIO_PROTECT_NP = 64, |
95 | PTHREAD_MUTEX_PP_NORMAL_NP |
96 | = PTHREAD_MUTEX_PRIO_PROTECT_NP | PTHREAD_MUTEX_NORMAL, |
97 | PTHREAD_MUTEX_PP_RECURSIVE_NP |
98 | = PTHREAD_MUTEX_PRIO_PROTECT_NP | PTHREAD_MUTEX_RECURSIVE_NP, |
99 | PTHREAD_MUTEX_PP_ERRORCHECK_NP |
100 | = PTHREAD_MUTEX_PRIO_PROTECT_NP | PTHREAD_MUTEX_ERRORCHECK_NP, |
101 | PTHREAD_MUTEX_PP_ADAPTIVE_NP |
102 | = PTHREAD_MUTEX_PRIO_PROTECT_NP | PTHREAD_MUTEX_ADAPTIVE_NP, |
103 | PTHREAD_MUTEX_ELISION_FLAGS_NP |
104 | = PTHREAD_MUTEX_ELISION_NP | PTHREAD_MUTEX_NO_ELISION_NP, |
105 | |
106 | PTHREAD_MUTEX_TIMED_ELISION_NP = |
107 | PTHREAD_MUTEX_TIMED_NP | PTHREAD_MUTEX_ELISION_NP, |
108 | PTHREAD_MUTEX_TIMED_NO_ELISION_NP = |
109 | PTHREAD_MUTEX_TIMED_NP | PTHREAD_MUTEX_NO_ELISION_NP, |
110 | }; |
111 | #define PTHREAD_MUTEX_PSHARED_BIT 128 |
112 | |
113 | /* See concurrency notes regarding __kind in struct __pthread_mutex_s |
114 | in sysdeps/nptl/bits/thread-shared-types.h. */ |
115 | #define PTHREAD_MUTEX_TYPE(m) \ |
116 | (atomic_load_relaxed (&((m)->__data.__kind)) & 127) |
117 | /* Don't include NO_ELISION, as that type is always the same |
118 | as the underlying lock type. */ |
119 | #define PTHREAD_MUTEX_TYPE_ELISION(m) \ |
120 | (atomic_load_relaxed (&((m)->__data.__kind)) \ |
121 | & (127 | PTHREAD_MUTEX_ELISION_NP)) |
122 | |
123 | #if LLL_PRIVATE == 0 && LLL_SHARED == 128 |
124 | # define PTHREAD_MUTEX_PSHARED(m) \ |
125 | (atomic_load_relaxed (&((m)->__data.__kind)) & 128) |
126 | #else |
127 | # define PTHREAD_MUTEX_PSHARED(m) \ |
128 | ((atomic_load_relaxed (&((m)->__data.__kind)) & 128) \ |
129 | ? LLL_SHARED : LLL_PRIVATE) |
130 | #endif |
131 | |
132 | /* The kernel when waking robust mutexes on exit never uses |
133 | FUTEX_PRIVATE_FLAG FUTEX_WAKE. */ |
134 | #define PTHREAD_ROBUST_MUTEX_PSHARED(m) LLL_SHARED |
135 | |
136 | /* Ceiling in __data.__lock. __data.__lock is signed, so don't |
137 | use the MSB bit in there, but in the mask also include that bit, |
138 | so that the compiler can optimize & PTHREAD_MUTEX_PRIO_CEILING_MASK |
139 | masking if the value is then shifted down by |
140 | PTHREAD_MUTEX_PRIO_CEILING_SHIFT. */ |
141 | #define PTHREAD_MUTEX_PRIO_CEILING_SHIFT 19 |
142 | #define PTHREAD_MUTEX_PRIO_CEILING_MASK 0xfff80000 |
143 | |
144 | |
145 | /* Flags in mutex attr. */ |
146 | #define PTHREAD_MUTEXATTR_PROTOCOL_SHIFT 28 |
147 | #define PTHREAD_MUTEXATTR_PROTOCOL_MASK 0x30000000 |
148 | #define PTHREAD_MUTEXATTR_PRIO_CEILING_SHIFT 12 |
149 | #define PTHREAD_MUTEXATTR_PRIO_CEILING_MASK 0x00fff000 |
150 | #define PTHREAD_MUTEXATTR_FLAG_ROBUST 0x40000000 |
151 | #define PTHREAD_MUTEXATTR_FLAG_PSHARED 0x80000000 |
152 | #define PTHREAD_MUTEXATTR_FLAG_BITS \ |
153 | (PTHREAD_MUTEXATTR_FLAG_ROBUST | PTHREAD_MUTEXATTR_FLAG_PSHARED \ |
154 | | PTHREAD_MUTEXATTR_PROTOCOL_MASK | PTHREAD_MUTEXATTR_PRIO_CEILING_MASK) |
155 | |
156 | |
157 | /* For the following, see pthread_rwlock_common.c. */ |
158 | #define PTHREAD_RWLOCK_WRPHASE 1 |
159 | #define PTHREAD_RWLOCK_WRLOCKED 2 |
160 | #define PTHREAD_RWLOCK_RWAITING 4 |
161 | #define PTHREAD_RWLOCK_READER_SHIFT 3 |
162 | #define PTHREAD_RWLOCK_READER_OVERFLOW ((unsigned int) 1 \ |
163 | << (sizeof (unsigned int) * 8 - 1)) |
164 | #define PTHREAD_RWLOCK_WRHANDOVER ((unsigned int) 1 \ |
165 | << (sizeof (unsigned int) * 8 - 1)) |
166 | #define PTHREAD_RWLOCK_FUTEX_USED 2 |
167 | |
168 | |
169 | /* Bits used in robust mutex implementation. */ |
170 | #define FUTEX_WAITERS 0x80000000 |
171 | #define FUTEX_OWNER_DIED 0x40000000 |
172 | #define FUTEX_TID_MASK 0x3fffffff |
173 | |
174 | |
175 | /* pthread_once definitions. See __pthread_once for how these are used. */ |
176 | #define __PTHREAD_ONCE_INPROGRESS 1 |
177 | #define __PTHREAD_ONCE_DONE 2 |
178 | #define __PTHREAD_ONCE_FORK_GEN_INCR 4 |
179 | |
180 | |
181 | /* Condition variable definitions. See __pthread_cond_wait_common. |
182 | Need to be defined here so there is one place from which |
183 | nptl_lock_constants can grab them. */ |
184 | #define __PTHREAD_COND_CLOCK_MONOTONIC_MASK 2 |
185 | #define __PTHREAD_COND_SHARED_MASK 1 |
186 | |
187 | |
188 | /* Internal variables. */ |
189 | |
190 | |
191 | /* Default pthread attributes. */ |
192 | extern struct pthread_attr __default_pthread_attr attribute_hidden; |
193 | extern int __default_pthread_attr_lock attribute_hidden; |
194 | |
195 | /* Size and alignment of static TLS block. */ |
196 | extern size_t __static_tls_size attribute_hidden; |
197 | extern size_t __static_tls_align_m1 attribute_hidden; |
198 | |
199 | /* Flag whether the machine is SMP or not. */ |
200 | extern int __is_smp attribute_hidden; |
201 | |
202 | /* Thread descriptor handling. */ |
203 | extern list_t __stack_user; |
204 | hidden_proto (__stack_user) |
205 | |
206 | /* Attribute handling. */ |
207 | extern struct pthread_attr *__attr_list attribute_hidden; |
208 | extern int __attr_list_lock attribute_hidden; |
209 | |
210 | /* Concurrency handling. */ |
211 | extern int __concurrency_level attribute_hidden; |
212 | |
213 | /* Thread-local data key handling. */ |
214 | extern struct pthread_key_struct __pthread_keys[PTHREAD_KEYS_MAX]; |
215 | hidden_proto (__pthread_keys) |
216 | |
217 | /* Number of threads running. */ |
218 | extern unsigned int __nptl_nthreads attribute_hidden; |
219 | |
220 | #ifndef __ASSUME_SET_ROBUST_LIST |
221 | /* Negative if we do not have the system call and we can use it. */ |
222 | extern int __set_robust_list_avail attribute_hidden; |
223 | #endif |
224 | |
225 | /* Thread Priority Protection. */ |
226 | extern int __sched_fifo_min_prio attribute_hidden; |
227 | extern int __sched_fifo_max_prio attribute_hidden; |
228 | extern void __init_sched_fifo_prio (void) attribute_hidden; |
229 | extern int __pthread_tpp_change_priority (int prev_prio, int new_prio) |
230 | attribute_hidden; |
231 | extern int __pthread_current_priority (void) attribute_hidden; |
232 | |
233 | /* The library can run in debugging mode where it performs a lot more |
234 | tests. */ |
235 | extern int __pthread_debug attribute_hidden; |
236 | /** For now disable debugging support. */ |
237 | #if 0 |
238 | # define DEBUGGING_P __builtin_expect (__pthread_debug, 0) |
239 | # define INVALID_TD_P(pd) (DEBUGGING_P && __find_in_stack_list (pd) == NULL) |
240 | # define INVALID_NOT_TERMINATED_TD_P(pd) INVALID_TD_P (pd) |
241 | #else |
242 | # define DEBUGGING_P 0 |
243 | /* Simplified test. This will not catch all invalid descriptors but |
244 | is better than nothing. And if the test triggers the thread |
245 | descriptor is guaranteed to be invalid. */ |
246 | # define INVALID_TD_P(pd) __builtin_expect ((pd)->tid <= 0, 0) |
247 | # define INVALID_NOT_TERMINATED_TD_P(pd) __builtin_expect ((pd)->tid < 0, 0) |
248 | #endif |
249 | |
250 | |
251 | /* Cancellation test. */ |
252 | #define CANCELLATION_P(self) \ |
253 | do { \ |
254 | int cancelhandling = THREAD_GETMEM (self, cancelhandling); \ |
255 | if (CANCEL_ENABLED_AND_CANCELED (cancelhandling)) \ |
256 | { \ |
257 | THREAD_SETMEM (self, result, PTHREAD_CANCELED); \ |
258 | __do_cancel (); \ |
259 | } \ |
260 | } while (0) |
261 | |
262 | |
263 | extern void __pthread_unwind (__pthread_unwind_buf_t *__buf) |
264 | __cleanup_fct_attribute __attribute ((__noreturn__)) |
265 | #if !defined SHARED && !IS_IN (libpthread) |
266 | weak_function |
267 | #endif |
268 | ; |
269 | extern void __pthread_unwind_next (__pthread_unwind_buf_t *__buf) |
270 | __cleanup_fct_attribute __attribute ((__noreturn__)) |
271 | #ifndef SHARED |
272 | weak_function |
273 | #endif |
274 | ; |
275 | extern void __pthread_register_cancel (__pthread_unwind_buf_t *__buf) |
276 | __cleanup_fct_attribute; |
277 | extern void __pthread_unregister_cancel (__pthread_unwind_buf_t *__buf) |
278 | __cleanup_fct_attribute; |
279 | #if IS_IN (libpthread) |
280 | hidden_proto (__pthread_unwind) |
281 | hidden_proto (__pthread_unwind_next) |
282 | hidden_proto (__pthread_register_cancel) |
283 | hidden_proto (__pthread_unregister_cancel) |
284 | # ifdef SHARED |
285 | extern void attribute_hidden pthread_cancel_init (void); |
286 | extern void __unwind_freeres (void); |
287 | # endif |
288 | #endif |
289 | |
290 | |
291 | /* Called when a thread reacts on a cancellation request. */ |
292 | static inline void |
293 | __attribute ((noreturn, always_inline)) |
294 | __do_cancel (void) |
295 | { |
296 | struct pthread *self = THREAD_SELF; |
297 | |
298 | /* Make sure we get no more cancellations. */ |
299 | THREAD_ATOMIC_BIT_SET (self, cancelhandling, EXITING_BIT); |
300 | |
301 | __pthread_unwind ((__pthread_unwind_buf_t *) |
302 | THREAD_GETMEM (self, cleanup_jmp_buf)); |
303 | } |
304 | |
305 | |
306 | /* Set cancellation mode to asynchronous. */ |
307 | #define CANCEL_ASYNC() \ |
308 | __pthread_enable_asynccancel () |
309 | /* Reset to previous cancellation mode. */ |
310 | #define CANCEL_RESET(oldtype) \ |
311 | __pthread_disable_asynccancel (oldtype) |
312 | |
313 | #if IS_IN (libc) |
314 | /* Same as CANCEL_ASYNC, but for use in libc.so. */ |
315 | # define LIBC_CANCEL_ASYNC() \ |
316 | __libc_enable_asynccancel () |
317 | /* Same as CANCEL_RESET, but for use in libc.so. */ |
318 | # define LIBC_CANCEL_RESET(oldtype) \ |
319 | __libc_disable_asynccancel (oldtype) |
320 | # define LIBC_CANCEL_HANDLED() \ |
321 | __asm (".globl " __SYMBOL_PREFIX "__libc_enable_asynccancel"); \ |
322 | __asm (".globl " __SYMBOL_PREFIX "__libc_disable_asynccancel") |
323 | #elif IS_IN (libpthread) |
324 | # define LIBC_CANCEL_ASYNC() CANCEL_ASYNC () |
325 | # define LIBC_CANCEL_RESET(val) CANCEL_RESET (val) |
326 | # define LIBC_CANCEL_HANDLED() \ |
327 | __asm (".globl " __SYMBOL_PREFIX "__pthread_enable_asynccancel"); \ |
328 | __asm (".globl " __SYMBOL_PREFIX "__pthread_disable_asynccancel") |
329 | #elif IS_IN (librt) |
330 | # define LIBC_CANCEL_ASYNC() \ |
331 | __librt_enable_asynccancel () |
332 | # define LIBC_CANCEL_RESET(val) \ |
333 | __librt_disable_asynccancel (val) |
334 | # define LIBC_CANCEL_HANDLED() \ |
335 | __asm (".globl " __SYMBOL_PREFIX "__librt_enable_asynccancel"); \ |
336 | __asm (".globl " __SYMBOL_PREFIX "__librt_disable_asynccancel") |
337 | #else |
338 | # define LIBC_CANCEL_ASYNC() 0 /* Just a dummy value. */ |
339 | # define LIBC_CANCEL_RESET(val) ((void)(val)) /* Nothing, but evaluate it. */ |
340 | # define LIBC_CANCEL_HANDLED() /* Nothing. */ |
341 | #endif |
342 | |
343 | |
344 | /* Internal prototypes. */ |
345 | |
346 | /* Thread list handling. */ |
347 | extern struct pthread *__find_in_stack_list (struct pthread *pd) |
348 | attribute_hidden; |
349 | |
350 | /* Deallocate a thread's stack after optionally making sure the thread |
351 | descriptor is still valid. */ |
352 | extern void __free_tcb (struct pthread *pd) attribute_hidden; |
353 | |
354 | /* Free allocated stack. */ |
355 | extern void __deallocate_stack (struct pthread *pd) attribute_hidden; |
356 | |
357 | /* Mark all the stacks except for the current one as available. This |
358 | function also re-initializes the lock for the stack cache. */ |
359 | extern void __reclaim_stacks (void) attribute_hidden; |
360 | |
361 | /* Make all threads's stacks executable. */ |
362 | extern int __make_stacks_executable (void **stack_endp) attribute_hidden; |
363 | |
364 | /* longjmp handling. */ |
365 | extern void __pthread_cleanup_upto (__jmp_buf target, char *targetframe); |
366 | #if IS_IN (libpthread) |
367 | hidden_proto (__pthread_cleanup_upto) |
368 | #endif |
369 | |
370 | |
371 | /* Functions with versioned interfaces. */ |
372 | extern int __pthread_create_2_1 (pthread_t *newthread, |
373 | const pthread_attr_t *attr, |
374 | void *(*start_routine) (void *), void *arg); |
375 | extern int __pthread_create_2_0 (pthread_t *newthread, |
376 | const pthread_attr_t *attr, |
377 | void *(*start_routine) (void *), void *arg); |
378 | extern int __pthread_attr_init_2_1 (pthread_attr_t *attr); |
379 | extern int __pthread_attr_init_2_0 (pthread_attr_t *attr); |
380 | |
381 | |
382 | /* Event handlers for libthread_db interface. */ |
383 | extern void __nptl_create_event (void); |
384 | extern void __nptl_death_event (void); |
385 | hidden_proto (__nptl_create_event) |
386 | hidden_proto (__nptl_death_event) |
387 | |
388 | /* Register the generation counter in the libpthread with the libc. */ |
389 | #ifdef TLS_MULTIPLE_THREADS_IN_TCB |
390 | extern void __libc_pthread_init (unsigned long int *ptr, |
391 | void (*reclaim) (void), |
392 | const struct pthread_functions *functions); |
393 | #else |
394 | extern int *__libc_pthread_init (unsigned long int *ptr, |
395 | void (*reclaim) (void), |
396 | const struct pthread_functions *functions); |
397 | |
398 | /* Variable set to a nonzero value either if more than one thread runs or ran, |
399 | or if a single-threaded process is trying to cancel itself. See |
400 | nptl/descr.h for more context on the single-threaded process case. */ |
401 | extern int __pthread_multiple_threads attribute_hidden; |
402 | /* Pointer to the corresponding variable in libc. */ |
403 | extern int *__libc_multiple_threads_ptr attribute_hidden; |
404 | #endif |
405 | |
406 | /* Find a thread given its TID. */ |
407 | extern struct pthread *__find_thread_by_id (pid_t tid) attribute_hidden |
408 | #ifdef SHARED |
409 | ; |
410 | #else |
411 | weak_function; |
412 | #define __find_thread_by_id(tid) \ |
413 | (__find_thread_by_id ? (__find_thread_by_id) (tid) : (struct pthread *) NULL) |
414 | #endif |
415 | |
416 | extern void __pthread_init_static_tls (struct link_map *) attribute_hidden; |
417 | |
418 | extern size_t __pthread_get_minstack (const pthread_attr_t *attr); |
419 | |
420 | /* Namespace save aliases. */ |
421 | extern int __pthread_getschedparam (pthread_t thread_id, int *policy, |
422 | struct sched_param *param); |
423 | extern int __pthread_setschedparam (pthread_t thread_id, int policy, |
424 | const struct sched_param *param); |
425 | extern int __pthread_setcancelstate (int state, int *oldstate); |
426 | extern int __pthread_mutex_init (pthread_mutex_t *__mutex, |
427 | const pthread_mutexattr_t *__mutexattr); |
428 | extern int __pthread_mutex_destroy (pthread_mutex_t *__mutex); |
429 | extern int __pthread_mutex_trylock (pthread_mutex_t *_mutex); |
430 | extern int __pthread_mutex_lock (pthread_mutex_t *__mutex); |
431 | extern int __pthread_mutex_timedlock (pthread_mutex_t *__mutex, |
432 | const struct timespec *__abstime); |
433 | extern int __pthread_mutex_cond_lock (pthread_mutex_t *__mutex) |
434 | attribute_hidden; |
435 | extern void __pthread_mutex_cond_lock_adjust (pthread_mutex_t *__mutex) |
436 | attribute_hidden; |
437 | extern int __pthread_mutex_unlock (pthread_mutex_t *__mutex); |
438 | extern int __pthread_mutex_unlock_usercnt (pthread_mutex_t *__mutex, |
439 | int __decr) attribute_hidden; |
440 | extern int __pthread_mutexattr_init (pthread_mutexattr_t *attr); |
441 | extern int __pthread_mutexattr_destroy (pthread_mutexattr_t *attr); |
442 | extern int __pthread_mutexattr_settype (pthread_mutexattr_t *attr, int kind); |
443 | extern int __pthread_attr_destroy (pthread_attr_t *attr); |
444 | extern int __pthread_attr_getdetachstate (const pthread_attr_t *attr, |
445 | int *detachstate); |
446 | extern int __pthread_attr_setdetachstate (pthread_attr_t *attr, |
447 | int detachstate); |
448 | extern int __pthread_attr_getinheritsched (const pthread_attr_t *attr, |
449 | int *inherit); |
450 | extern int __pthread_attr_setinheritsched (pthread_attr_t *attr, int inherit); |
451 | extern int __pthread_attr_getschedparam (const pthread_attr_t *attr, |
452 | struct sched_param *param); |
453 | extern int __pthread_attr_setschedparam (pthread_attr_t *attr, |
454 | const struct sched_param *param); |
455 | extern int __pthread_attr_getschedpolicy (const pthread_attr_t *attr, |
456 | int *policy); |
457 | extern int __pthread_attr_setschedpolicy (pthread_attr_t *attr, int policy); |
458 | extern int __pthread_attr_getscope (const pthread_attr_t *attr, int *scope); |
459 | extern int __pthread_attr_setscope (pthread_attr_t *attr, int scope); |
460 | extern int __pthread_attr_getstackaddr (const pthread_attr_t *__restrict |
461 | __attr, void **__restrict __stackaddr); |
462 | extern int __pthread_attr_setstackaddr (pthread_attr_t *__attr, |
463 | void *__stackaddr); |
464 | extern int __pthread_attr_getstacksize (const pthread_attr_t *__restrict |
465 | __attr, |
466 | size_t *__restrict __stacksize); |
467 | extern int __pthread_attr_setstacksize (pthread_attr_t *__attr, |
468 | size_t __stacksize); |
469 | extern int __pthread_attr_getstack (const pthread_attr_t *__restrict __attr, |
470 | void **__restrict __stackaddr, |
471 | size_t *__restrict __stacksize); |
472 | extern int __pthread_attr_setstack (pthread_attr_t *__attr, void *__stackaddr, |
473 | size_t __stacksize); |
474 | extern int __pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock, |
475 | const pthread_rwlockattr_t *__restrict |
476 | __attr); |
477 | extern int __pthread_rwlock_destroy (pthread_rwlock_t *__rwlock); |
478 | extern int __pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock); |
479 | extern int __pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock); |
480 | extern int __pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock); |
481 | extern int __pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock); |
482 | extern int __pthread_rwlock_unlock (pthread_rwlock_t *__rwlock); |
483 | extern int __pthread_cond_broadcast (pthread_cond_t *cond); |
484 | extern int __pthread_cond_destroy (pthread_cond_t *cond); |
485 | extern int __pthread_cond_init (pthread_cond_t *cond, |
486 | const pthread_condattr_t *cond_attr); |
487 | extern int __pthread_cond_signal (pthread_cond_t *cond); |
488 | extern int __pthread_cond_wait (pthread_cond_t *cond, pthread_mutex_t *mutex); |
489 | extern int __pthread_cond_timedwait (pthread_cond_t *cond, |
490 | pthread_mutex_t *mutex, |
491 | const struct timespec *abstime); |
492 | extern int __pthread_condattr_destroy (pthread_condattr_t *attr); |
493 | extern int __pthread_condattr_init (pthread_condattr_t *attr); |
494 | extern int __pthread_key_create (pthread_key_t *key, void (*destr) (void *)); |
495 | extern int __pthread_key_delete (pthread_key_t key); |
496 | extern void *__pthread_getspecific (pthread_key_t key); |
497 | extern int __pthread_setspecific (pthread_key_t key, const void *value); |
498 | extern int __pthread_once (pthread_once_t *once_control, |
499 | void (*init_routine) (void)); |
500 | extern int __pthread_atfork (void (*prepare) (void), void (*parent) (void), |
501 | void (*child) (void)); |
502 | extern pthread_t __pthread_self (void); |
503 | extern int __pthread_equal (pthread_t thread1, pthread_t thread2); |
504 | extern int __pthread_detach (pthread_t th); |
505 | extern int __pthread_cancel (pthread_t th); |
506 | extern int __pthread_kill (pthread_t threadid, int signo); |
507 | extern void __pthread_exit (void *value) __attribute__ ((__noreturn__)); |
508 | extern int __pthread_join (pthread_t threadid, void **thread_return); |
509 | extern int __pthread_setcanceltype (int type, int *oldtype); |
510 | extern int __pthread_enable_asynccancel (void) attribute_hidden; |
511 | extern void __pthread_disable_asynccancel (int oldtype) attribute_hidden; |
512 | extern void __pthread_testcancel (void); |
513 | extern int __pthread_timedjoin_ex (pthread_t, void **, const struct timespec *, |
514 | bool); |
515 | |
516 | #if IS_IN (libpthread) |
517 | hidden_proto (__pthread_mutex_init) |
518 | hidden_proto (__pthread_mutex_destroy) |
519 | hidden_proto (__pthread_mutex_lock) |
520 | hidden_proto (__pthread_mutex_trylock) |
521 | hidden_proto (__pthread_mutex_unlock) |
522 | hidden_proto (__pthread_rwlock_rdlock) |
523 | hidden_proto (__pthread_rwlock_wrlock) |
524 | hidden_proto (__pthread_rwlock_unlock) |
525 | hidden_proto (__pthread_key_create) |
526 | hidden_proto (__pthread_getspecific) |
527 | hidden_proto (__pthread_setspecific) |
528 | hidden_proto (__pthread_once) |
529 | hidden_proto (__pthread_setcancelstate) |
530 | hidden_proto (__pthread_testcancel) |
531 | hidden_proto (__pthread_mutexattr_init) |
532 | hidden_proto (__pthread_mutexattr_settype) |
533 | hidden_proto (__pthread_timedjoin_ex) |
534 | #endif |
535 | |
536 | extern int __pthread_cond_broadcast_2_0 (pthread_cond_2_0_t *cond); |
537 | extern int __pthread_cond_destroy_2_0 (pthread_cond_2_0_t *cond); |
538 | extern int __pthread_cond_init_2_0 (pthread_cond_2_0_t *cond, |
539 | const pthread_condattr_t *cond_attr); |
540 | extern int __pthread_cond_signal_2_0 (pthread_cond_2_0_t *cond); |
541 | extern int __pthread_cond_timedwait_2_0 (pthread_cond_2_0_t *cond, |
542 | pthread_mutex_t *mutex, |
543 | const struct timespec *abstime); |
544 | extern int __pthread_cond_wait_2_0 (pthread_cond_2_0_t *cond, |
545 | pthread_mutex_t *mutex); |
546 | |
547 | extern int __pthread_getaffinity_np (pthread_t th, size_t cpusetsize, |
548 | cpu_set_t *cpuset); |
549 | |
550 | /* The two functions are in libc.so and not exported. */ |
551 | extern int __libc_enable_asynccancel (void) attribute_hidden; |
552 | extern void __libc_disable_asynccancel (int oldtype) attribute_hidden; |
553 | |
554 | |
555 | /* The two functions are in librt.so and not exported. */ |
556 | extern int __librt_enable_asynccancel (void) attribute_hidden; |
557 | extern void __librt_disable_asynccancel (int oldtype) attribute_hidden; |
558 | |
559 | #if IS_IN (libpthread) |
560 | /* Special versions which use non-exported functions. */ |
561 | extern void __pthread_cleanup_push (struct _pthread_cleanup_buffer *buffer, |
562 | void (*routine) (void *), void *arg) |
563 | attribute_hidden; |
564 | |
565 | /* Replace cleanup macros defined in <pthread.h> with internal |
566 | versions that don't depend on unwind info and better support |
567 | cancellation. */ |
568 | # undef pthread_cleanup_push |
569 | # define pthread_cleanup_push(routine,arg) \ |
570 | { struct _pthread_cleanup_buffer _buffer; \ |
571 | __pthread_cleanup_push (&_buffer, (routine), (arg)); |
572 | |
573 | extern void __pthread_cleanup_pop (struct _pthread_cleanup_buffer *buffer, |
574 | int execute) attribute_hidden; |
575 | # undef pthread_cleanup_pop |
576 | # define pthread_cleanup_pop(execute) \ |
577 | __pthread_cleanup_pop (&_buffer, (execute)); } |
578 | #endif |
579 | |
580 | extern void __pthread_cleanup_push_defer (struct _pthread_cleanup_buffer *buffer, |
581 | void (*routine) (void *), void *arg); |
582 | extern void __pthread_cleanup_pop_restore (struct _pthread_cleanup_buffer *buffer, |
583 | int execute); |
584 | |
585 | /* Old cleanup interfaces, still used in libc.so. */ |
586 | extern void _pthread_cleanup_push (struct _pthread_cleanup_buffer *buffer, |
587 | void (*routine) (void *), void *arg); |
588 | extern void _pthread_cleanup_pop (struct _pthread_cleanup_buffer *buffer, |
589 | int execute); |
590 | extern void _pthread_cleanup_push_defer (struct _pthread_cleanup_buffer *buffer, |
591 | void (*routine) (void *), void *arg); |
592 | extern void _pthread_cleanup_pop_restore (struct _pthread_cleanup_buffer *buffer, |
593 | int execute); |
594 | |
595 | extern void __nptl_deallocate_tsd (void) attribute_hidden; |
596 | |
597 | extern void __nptl_setxid_error (struct xid_command *cmdp, int error) |
598 | attribute_hidden; |
599 | extern int __nptl_setxid (struct xid_command *cmdp) attribute_hidden; |
600 | #ifndef SHARED |
601 | extern void __nptl_set_robust (struct pthread *self); |
602 | #endif |
603 | |
604 | extern void __free_stacks (size_t limit) attribute_hidden; |
605 | |
606 | extern void __wait_lookup_done (void) attribute_hidden; |
607 | |
608 | #ifdef SHARED |
609 | # define PTHREAD_STATIC_FN_REQUIRE(name) |
610 | #else |
611 | # define PTHREAD_STATIC_FN_REQUIRE(name) __asm (".globl " #name); |
612 | #endif |
613 | |
614 | /* Returns 0 if POL is a valid scheduling policy. */ |
615 | static inline int |
616 | check_sched_policy_attr (int pol) |
617 | { |
618 | if (pol == SCHED_OTHER || pol == SCHED_FIFO || pol == SCHED_RR) |
619 | return 0; |
620 | |
621 | return EINVAL; |
622 | } |
623 | |
624 | /* Returns 0 if PR is within the accepted range of priority values for |
625 | the scheduling policy POL or EINVAL otherwise. */ |
626 | static inline int |
627 | check_sched_priority_attr (int pr, int pol) |
628 | { |
629 | int min = __sched_get_priority_min (pol); |
630 | int max = __sched_get_priority_max (pol); |
631 | |
632 | if (min >= 0 && max >= 0 && pr >= min && pr <= max) |
633 | return 0; |
634 | |
635 | return EINVAL; |
636 | } |
637 | |
638 | /* Returns 0 if ST is a valid stack size for a thread stack and EINVAL |
639 | otherwise. */ |
640 | static inline int |
641 | check_stacksize_attr (size_t st) |
642 | { |
643 | if (st >= PTHREAD_STACK_MIN) |
644 | return 0; |
645 | |
646 | return EINVAL; |
647 | } |
648 | |
649 | #define ASSERT_TYPE_SIZE(type, size) \ |
650 | _Static_assert (sizeof (type) == size, \ |
651 | "sizeof (" #type ") != " #size) |
652 | |
653 | #define ASSERT_PTHREAD_INTERNAL_SIZE(type, internal) \ |
654 | _Static_assert (sizeof ((type) { { 0 } }).__size >= sizeof (internal),\ |
655 | "sizeof (" #type ".__size) < sizeof (" #internal ")") |
656 | |
657 | #define ASSERT_PTHREAD_STRING(x) __STRING (x) |
658 | #define ASSERT_PTHREAD_INTERNAL_OFFSET(type, member, offset) \ |
659 | _Static_assert (offsetof (type, member) == offset, \ |
660 | "offset of " #member " field of " #type " != " \ |
661 | ASSERT_PTHREAD_STRING (offset)) |
662 | |
663 | #endif /* pthreadP.h */ |
664 | |