Andrea Falcone | 1c4977f | 2020-07-23 10:58:25 -0400 | [diff] [blame^] | 1 | /* |
| 2 | * Copyright (C) 2008 The Android Open Source Project |
| 3 | * All rights reserved. |
| 4 | * |
| 5 | * Redistribution and use in source and binary forms, with or without |
| 6 | * modification, are permitted provided that the following conditions |
| 7 | * are met: |
| 8 | * * Redistributions of source code must retain the above copyright |
| 9 | * notice, this list of conditions and the following disclaimer. |
| 10 | * * Redistributions in binary form must reproduce the above copyright |
| 11 | * notice, this list of conditions and the following disclaimer in |
| 12 | * the documentation and/or other materials provided with the |
| 13 | * distribution. |
| 14 | * |
| 15 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| 16 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| 17 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS |
| 18 | * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE |
| 19 | * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, |
| 20 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, |
| 21 | * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS |
| 22 | * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED |
| 23 | * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, |
| 24 | * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT |
| 25 | * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
| 26 | * SUCH DAMAGE. |
| 27 | */ |
| 28 | |
| 29 | #ifndef _PTHREAD_H_ |
| 30 | #define _PTHREAD_H_ |
| 31 | |
| 32 | #include <limits.h> |
| 33 | #include <bits/pthread_types.h> |
| 34 | #include <sched.h> |
| 35 | #include <sys/cdefs.h> |
| 36 | #include <sys/types.h> |
| 37 | #include <time.h> |
| 38 | |
| 39 | __BEGIN_DECLS |
| 40 | |
| 41 | enum { |
| 42 | PTHREAD_MUTEX_NORMAL = 0, |
| 43 | PTHREAD_MUTEX_RECURSIVE = 1, |
| 44 | PTHREAD_MUTEX_ERRORCHECK = 2, |
| 45 | |
| 46 | PTHREAD_MUTEX_ERRORCHECK_NP = PTHREAD_MUTEX_ERRORCHECK, |
| 47 | PTHREAD_MUTEX_RECURSIVE_NP = PTHREAD_MUTEX_RECURSIVE, |
| 48 | |
| 49 | PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL |
| 50 | }; |
| 51 | |
| 52 | #define PTHREAD_MUTEX_INITIALIZER { { ((PTHREAD_MUTEX_NORMAL & 3) << 14) } } |
| 53 | #define PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP { { ((PTHREAD_MUTEX_RECURSIVE & 3) << 14) } } |
| 54 | #define PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP { { ((PTHREAD_MUTEX_ERRORCHECK & 3) << 14) } } |
| 55 | |
| 56 | #define PTHREAD_COND_INITIALIZER { { 0 } } |
| 57 | #if __ANDROID_API__ >= __ANDROID_API_L__ |
| 58 | #define PTHREAD_COND_INITIALIZER_MONOTONIC_NP { { 1 << 1 } } |
| 59 | #endif |
| 60 | |
| 61 | #define PTHREAD_RWLOCK_INITIALIZER { { 0 } } |
| 62 | |
| 63 | enum { |
| 64 | PTHREAD_RWLOCK_PREFER_READER_NP = 0, |
| 65 | PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP = 1, |
| 66 | }; |
| 67 | |
| 68 | #define PTHREAD_ONCE_INIT 0 |
| 69 | |
| 70 | #if __ANDROID_API__ >= __ANDROID_API_N__ |
| 71 | #define PTHREAD_BARRIER_SERIAL_THREAD -1 |
| 72 | #endif |
| 73 | |
| 74 | #if defined(__LP64__) |
| 75 | #define PTHREAD_STACK_MIN (4 * PAGE_SIZE) |
| 76 | #else |
| 77 | #define PTHREAD_STACK_MIN (2 * PAGE_SIZE) |
| 78 | #endif |
| 79 | |
| 80 | #define PTHREAD_CREATE_DETACHED 1 |
| 81 | #define PTHREAD_CREATE_JOINABLE 0 |
| 82 | |
| 83 | #define PTHREAD_EXPLICIT_SCHED 0 |
| 84 | #define PTHREAD_INHERIT_SCHED 1 |
| 85 | |
| 86 | #define PTHREAD_PRIO_NONE 0 |
| 87 | #define PTHREAD_PRIO_INHERIT 1 |
| 88 | |
| 89 | #define PTHREAD_PROCESS_PRIVATE 0 |
| 90 | #define PTHREAD_PROCESS_SHARED 1 |
| 91 | |
| 92 | #define PTHREAD_SCOPE_SYSTEM 0 |
| 93 | #define PTHREAD_SCOPE_PROCESS 1 |
| 94 | |
| 95 | int pthread_atfork(void (*__prepare)(void), void (*__parent)(void), void (*__child)(void)); |
| 96 | |
| 97 | int pthread_attr_destroy(pthread_attr_t* __attr); |
| 98 | int pthread_attr_getdetachstate(const pthread_attr_t* __attr, int* __state); |
| 99 | int pthread_attr_getguardsize(const pthread_attr_t* __attr, size_t* __size); |
| 100 | |
| 101 | #if __ANDROID_API__ >= 28 |
| 102 | int pthread_attr_getinheritsched(const pthread_attr_t* __attr, int* __flag) __INTRODUCED_IN(28); |
| 103 | #endif /* __ANDROID_API__ >= 28 */ |
| 104 | |
| 105 | int pthread_attr_getschedparam(const pthread_attr_t* __attr, struct sched_param* __param); |
| 106 | int pthread_attr_getschedpolicy(const pthread_attr_t* __attr, int* __policy); |
| 107 | int pthread_attr_getscope(const pthread_attr_t* __attr, int* __scope); |
| 108 | int pthread_attr_getstack(const pthread_attr_t* __attr, void** __addr, size_t* __size); |
| 109 | int pthread_attr_getstacksize(const pthread_attr_t* __attr, size_t* __size); |
| 110 | int pthread_attr_init(pthread_attr_t* __attr); |
| 111 | int pthread_attr_setdetachstate(pthread_attr_t* __attr, int __state); |
| 112 | int pthread_attr_setguardsize(pthread_attr_t* __attr, size_t __size); |
| 113 | |
| 114 | #if __ANDROID_API__ >= 28 |
| 115 | int pthread_attr_setinheritsched(pthread_attr_t* __attr, int __flag) __INTRODUCED_IN(28); |
| 116 | #endif /* __ANDROID_API__ >= 28 */ |
| 117 | |
| 118 | int pthread_attr_setschedparam(pthread_attr_t* __attr, const struct sched_param* __param); |
| 119 | int pthread_attr_setschedpolicy(pthread_attr_t* __attr, int __policy); |
| 120 | int pthread_attr_setscope(pthread_attr_t* __attr, int __scope); |
| 121 | int pthread_attr_setstack(pthread_attr_t* __attr, void* __addr, size_t __size); |
| 122 | int pthread_attr_setstacksize(pthread_attr_t* __addr, size_t __size); |
| 123 | |
| 124 | int pthread_condattr_destroy(pthread_condattr_t* __attr); |
| 125 | |
| 126 | #if __ANDROID_API__ >= 21 |
| 127 | int pthread_condattr_getclock(const pthread_condattr_t* __attr, clockid_t* __clock) __INTRODUCED_IN(21); |
| 128 | #endif /* __ANDROID_API__ >= 21 */ |
| 129 | |
| 130 | int pthread_condattr_getpshared(const pthread_condattr_t* __attr, int* __shared); |
| 131 | int pthread_condattr_init(pthread_condattr_t* __attr); |
| 132 | |
| 133 | #if __ANDROID_API__ >= 21 |
| 134 | int pthread_condattr_setclock(pthread_condattr_t* __attr, clockid_t __clock) __INTRODUCED_IN(21); |
| 135 | #endif /* __ANDROID_API__ >= 21 */ |
| 136 | |
| 137 | int pthread_condattr_setpshared(pthread_condattr_t* __attr, int __shared); |
| 138 | |
| 139 | int pthread_cond_broadcast(pthread_cond_t* __cond); |
| 140 | |
| 141 | #if __ANDROID_API__ >= 30 |
| 142 | int pthread_cond_clockwait(pthread_cond_t* __cond, pthread_mutex_t* __mutex, clockid_t __clock, |
| 143 | const struct timespec* __timeout) __INTRODUCED_IN(30); |
| 144 | #endif /* __ANDROID_API__ >= 30 */ |
| 145 | |
| 146 | int pthread_cond_destroy(pthread_cond_t* __cond); |
| 147 | int pthread_cond_init(pthread_cond_t* __cond, const pthread_condattr_t* __attr); |
| 148 | int pthread_cond_signal(pthread_cond_t* __cond); |
| 149 | int pthread_cond_timedwait(pthread_cond_t* __cond, pthread_mutex_t* __mutex, const struct timespec* __timeout); |
| 150 | /* |
| 151 | * Condition variables use CLOCK_REALTIME by default for their timeouts, however that is |
| 152 | * typically inappropriate, since that clock can change dramatically, causing the timeout to |
| 153 | * either expire earlier or much later than intended. |
| 154 | * Condition variables have an initialization option to use CLOCK_MONOTONIC, and in addition, |
| 155 | * Android provides pthread_cond_timedwait_monotonic_np to use CLOCK_MONOTONIC on a condition |
| 156 | * variable for this single wait no matter how it was initialized. |
| 157 | * Note that pthread_cond_clockwait() allows specifying an arbitrary clock and has superseded this |
| 158 | * function. |
| 159 | */ |
| 160 | |
| 161 | #if (!defined(__LP64__)) || (defined(__LP64__) && __ANDROID_API__ >= 28) |
| 162 | int pthread_cond_timedwait_monotonic_np(pthread_cond_t* __cond, pthread_mutex_t* __mutex, |
| 163 | const struct timespec* __timeout) __INTRODUCED_IN_64(28); |
| 164 | #endif /* (!defined(__LP64__)) || (defined(__LP64__) && __ANDROID_API__ >= 28) */ |
| 165 | |
| 166 | int pthread_cond_wait(pthread_cond_t* __cond, pthread_mutex_t* __mutex); |
| 167 | |
| 168 | #if defined(__clang__) |
| 169 | /* |
| 170 | * Disable -Wbuiltin-requires-header because clang confuses this declaration with the one defined in |
| 171 | * "llvm/tools/clang/include/clang/Basic/Builtins.def", which did not define any formal arguments. |
| 172 | * It seems to be an upstream bug and the fix (https://reviews.llvm.org/D58531) is still under |
| 173 | * review. Thus, let's disable the warning for this function declaration. |
| 174 | */ |
| 175 | #pragma clang diagnostic push |
| 176 | #pragma clang diagnostic ignored "-Wbuiltin-requires-header" |
| 177 | #endif |
| 178 | int pthread_create(pthread_t* __pthread_ptr, pthread_attr_t const* __attr, void* (*__start_routine)(void*), void*); |
| 179 | #if defined(__clang__) |
| 180 | #pragma clang diagnostic pop |
| 181 | #endif |
| 182 | |
| 183 | int pthread_detach(pthread_t __pthread); |
| 184 | void pthread_exit(void* __return_value) __noreturn; |
| 185 | |
| 186 | int pthread_equal(pthread_t __lhs, pthread_t __rhs); |
| 187 | |
| 188 | int pthread_getattr_np(pthread_t __pthread, pthread_attr_t* __attr); |
| 189 | |
| 190 | int pthread_getcpuclockid(pthread_t __pthread, clockid_t* __clock); |
| 191 | |
| 192 | int pthread_getschedparam(pthread_t __pthread, int* __policy, struct sched_param* __param); |
| 193 | |
| 194 | void* pthread_getspecific(pthread_key_t __key); |
| 195 | |
| 196 | |
| 197 | #if __ANDROID_API__ >= 21 |
| 198 | pid_t pthread_gettid_np(pthread_t __pthread) __INTRODUCED_IN(21); |
| 199 | #endif /* __ANDROID_API__ >= 21 */ |
| 200 | |
| 201 | |
| 202 | int pthread_join(pthread_t __pthread, void** __return_value_ptr); |
| 203 | |
| 204 | int pthread_key_create(pthread_key_t* __key_ptr, void (*__key_destructor)(void*)); |
| 205 | int pthread_key_delete(pthread_key_t __key); |
| 206 | |
| 207 | int pthread_mutexattr_destroy(pthread_mutexattr_t* __attr); |
| 208 | int pthread_mutexattr_getpshared(const pthread_mutexattr_t* __attr, int* __shared); |
| 209 | int pthread_mutexattr_gettype(const pthread_mutexattr_t* __attr, int* __type); |
| 210 | |
| 211 | #if __ANDROID_API__ >= 28 |
| 212 | int pthread_mutexattr_getprotocol(const pthread_mutexattr_t* __attr, int* __protocol) __INTRODUCED_IN(28); |
| 213 | #endif /* __ANDROID_API__ >= 28 */ |
| 214 | |
| 215 | int pthread_mutexattr_init(pthread_mutexattr_t* __attr); |
| 216 | int pthread_mutexattr_setpshared(pthread_mutexattr_t* __attr, int __shared); |
| 217 | int pthread_mutexattr_settype(pthread_mutexattr_t* __attr, int __type); |
| 218 | |
| 219 | #if __ANDROID_API__ >= 28 |
| 220 | int pthread_mutexattr_setprotocol(pthread_mutexattr_t* __attr, int __protocol) __INTRODUCED_IN(28); |
| 221 | #endif /* __ANDROID_API__ >= 28 */ |
| 222 | |
| 223 | |
| 224 | |
| 225 | #if __ANDROID_API__ >= 30 |
| 226 | int pthread_mutex_clocklock(pthread_mutex_t* __mutex, clockid_t __clock, |
| 227 | const struct timespec* __abstime) __INTRODUCED_IN(30); |
| 228 | #endif /* __ANDROID_API__ >= 30 */ |
| 229 | |
| 230 | int pthread_mutex_destroy(pthread_mutex_t* __mutex); |
| 231 | int pthread_mutex_init(pthread_mutex_t* __mutex, const pthread_mutexattr_t* __attr); |
| 232 | int pthread_mutex_lock(pthread_mutex_t* __mutex); |
| 233 | |
| 234 | #if __ANDROID_API__ >= 21 |
| 235 | int pthread_mutex_timedlock(pthread_mutex_t* __mutex, const struct timespec* __timeout) |
| 236 | __INTRODUCED_IN(21); |
| 237 | #endif /* __ANDROID_API__ >= 21 */ |
| 238 | |
| 239 | |
| 240 | /* |
| 241 | * POSIX historically only supported using pthread_mutex_timedlock() with CLOCK_REALTIME, however |
| 242 | * that is typically inappropriate, since that clock can change dramatically, causing the timeout to |
| 243 | * either expire earlier or much later than intended. |
| 244 | * This function is added to use a timespec based on CLOCK_MONOTONIC that does not suffer |
| 245 | * from this issue. |
| 246 | * Note that pthread_mutex_clocklock() allows specifying an arbitrary clock and has superseded this |
| 247 | * function. |
| 248 | */ |
| 249 | |
| 250 | #if __ANDROID_API__ >= 28 |
| 251 | int pthread_mutex_timedlock_monotonic_np(pthread_mutex_t* __mutex, const struct timespec* __timeout) |
| 252 | __INTRODUCED_IN(28); |
| 253 | #endif /* __ANDROID_API__ >= 28 */ |
| 254 | |
| 255 | int pthread_mutex_trylock(pthread_mutex_t* __mutex); |
| 256 | int pthread_mutex_unlock(pthread_mutex_t* __mutex); |
| 257 | |
| 258 | #if __ANDROID_API__ < 21 |
| 259 | /* |
| 260 | * Cruft for supporting old API levels. Pre-L we didn't have the proper POSIX |
| 261 | * APIs for things, but instead had some locally grown, artisan equivalents. |
| 262 | * Keep exposing the old prototypes on old API levels so we don't regress |
| 263 | * functionality. |
| 264 | * |
| 265 | * See the following bugs: |
| 266 | * * https://github.com/android-ndk/ndk/issues/420 |
| 267 | * * https://github.com/android-ndk/ndk/issues/423 |
| 268 | * * https://stackoverflow.com/q/44580542/632035 |
| 269 | */ |
| 270 | int pthread_mutex_lock_timeout_np(pthread_mutex_t* __mutex, unsigned __timeout_ms); |
| 271 | int pthread_cond_timeout_np(pthread_cond_t* __cond, pthread_mutex_t* __mutex, unsigned __timeout_ms); |
| 272 | int pthread_cond_timedwait_relative_np(pthread_cond_t* __cond, pthread_mutex_t* __mutex, const struct timespec* __relative_timeout); |
| 273 | #endif |
| 274 | |
| 275 | int pthread_once(pthread_once_t* __once, void (*__init_routine)(void)); |
| 276 | |
| 277 | int pthread_rwlockattr_init(pthread_rwlockattr_t* __attr); |
| 278 | int pthread_rwlockattr_destroy(pthread_rwlockattr_t* __attr); |
| 279 | int pthread_rwlockattr_getpshared(const pthread_rwlockattr_t* __attr, int* __shared); |
| 280 | int pthread_rwlockattr_setpshared(pthread_rwlockattr_t* __attr, int __shared); |
| 281 | |
| 282 | #if __ANDROID_API__ >= 23 |
| 283 | int pthread_rwlockattr_getkind_np(const pthread_rwlockattr_t* __attr, int* __kind) |
| 284 | __INTRODUCED_IN(23); |
| 285 | int pthread_rwlockattr_setkind_np(pthread_rwlockattr_t* __attr, int __kind) __INTRODUCED_IN(23); |
| 286 | #endif /* __ANDROID_API__ >= 23 */ |
| 287 | |
| 288 | |
| 289 | |
| 290 | #if __ANDROID_API__ >= 30 |
| 291 | int pthread_rwlock_clockrdlock(pthread_rwlock_t* __rwlock, clockid_t __clock, |
| 292 | const struct timespec* __timeout) __INTRODUCED_IN(30); |
| 293 | int pthread_rwlock_clockwrlock(pthread_rwlock_t* __rwlock, clockid_t __clock, |
| 294 | const struct timespec* __timeout) __INTRODUCED_IN(30); |
| 295 | #endif /* __ANDROID_API__ >= 30 */ |
| 296 | |
| 297 | int pthread_rwlock_destroy(pthread_rwlock_t* __rwlock); |
| 298 | int pthread_rwlock_init(pthread_rwlock_t* __rwlock, const pthread_rwlockattr_t* __attr); |
| 299 | int pthread_rwlock_rdlock(pthread_rwlock_t* __rwlock); |
| 300 | int pthread_rwlock_timedrdlock(pthread_rwlock_t* __rwlock, const struct timespec* __timeout); |
| 301 | /* See the comment on pthread_mutex_timedlock_monotonic_np for usage of this function. */ |
| 302 | |
| 303 | #if __ANDROID_API__ >= 28 |
| 304 | int pthread_rwlock_timedrdlock_monotonic_np(pthread_rwlock_t* __rwlock, |
| 305 | const struct timespec* __timeout) __INTRODUCED_IN(28); |
| 306 | #endif /* __ANDROID_API__ >= 28 */ |
| 307 | |
| 308 | int pthread_rwlock_timedwrlock(pthread_rwlock_t* __rwlock, const struct timespec* __timeout); |
| 309 | /* See the comment on pthread_mutex_timedlock_monotonic_np for usage of this function. */ |
| 310 | |
| 311 | #if __ANDROID_API__ >= 28 |
| 312 | int pthread_rwlock_timedwrlock_monotonic_np(pthread_rwlock_t* __rwlock, |
| 313 | const struct timespec* __timeout) __INTRODUCED_IN(28); |
| 314 | #endif /* __ANDROID_API__ >= 28 */ |
| 315 | |
| 316 | int pthread_rwlock_tryrdlock(pthread_rwlock_t* __rwlock); |
| 317 | int pthread_rwlock_trywrlock(pthread_rwlock_t* __rwlock); |
| 318 | int pthread_rwlock_unlock(pthread_rwlock_t* __rwlock); |
| 319 | int pthread_rwlock_wrlock(pthread_rwlock_t* __rwlock); |
| 320 | |
| 321 | #if __ANDROID_API__ >= __ANDROID_API_N__ |
| 322 | int pthread_barrierattr_init(pthread_barrierattr_t* __attr) __INTRODUCED_IN(24); |
| 323 | int pthread_barrierattr_destroy(pthread_barrierattr_t* __attr) __INTRODUCED_IN(24); |
| 324 | int pthread_barrierattr_getpshared(const pthread_barrierattr_t* __attr, int* __shared) __INTRODUCED_IN(24); |
| 325 | int pthread_barrierattr_setpshared(pthread_barrierattr_t* __attr, int __shared) __INTRODUCED_IN(24); |
| 326 | #endif |
| 327 | |
| 328 | #if __ANDROID_API__ >= __ANDROID_API_N__ |
| 329 | int pthread_barrier_init(pthread_barrier_t* __barrier, const pthread_barrierattr_t* __attr, unsigned __count) __INTRODUCED_IN(24); |
| 330 | int pthread_barrier_destroy(pthread_barrier_t* __barrier) __INTRODUCED_IN(24); |
| 331 | int pthread_barrier_wait(pthread_barrier_t* __barrier) __INTRODUCED_IN(24); |
| 332 | #endif |
| 333 | |
| 334 | #if __ANDROID_API__ >= __ANDROID_API_N__ |
| 335 | int pthread_spin_destroy(pthread_spinlock_t* __spinlock) __INTRODUCED_IN(24); |
| 336 | int pthread_spin_init(pthread_spinlock_t* __spinlock, int __shared) __INTRODUCED_IN(24); |
| 337 | int pthread_spin_lock(pthread_spinlock_t* __spinlock) __INTRODUCED_IN(24); |
| 338 | int pthread_spin_trylock(pthread_spinlock_t* __spinlock) __INTRODUCED_IN(24); |
| 339 | int pthread_spin_unlock(pthread_spinlock_t* __spinlock) __INTRODUCED_IN(24); |
| 340 | #endif |
| 341 | |
| 342 | pthread_t pthread_self(void) __attribute_const__; |
| 343 | |
| 344 | #if defined(__USE_GNU) |
| 345 | |
| 346 | #if __ANDROID_API__ >= 26 |
| 347 | int pthread_getname_np(pthread_t __pthread, char* __buf, size_t __n) __INTRODUCED_IN(26); |
| 348 | #endif /* __ANDROID_API__ >= 26 */ |
| 349 | |
| 350 | #endif |
| 351 | /* TODO: this should be __USE_GNU too. */ |
| 352 | int pthread_setname_np(pthread_t __pthread, const char* __name); |
| 353 | |
| 354 | int pthread_setschedparam(pthread_t __pthread, int __policy, const struct sched_param* __param); |
| 355 | |
| 356 | #if __ANDROID_API__ >= 28 |
| 357 | int pthread_setschedprio(pthread_t __pthread, int __priority) __INTRODUCED_IN(28); |
| 358 | #endif /* __ANDROID_API__ >= 28 */ |
| 359 | |
| 360 | |
| 361 | int pthread_setspecific(pthread_key_t __key, const void* __value); |
| 362 | |
| 363 | typedef void (*__pthread_cleanup_func_t)(void*); |
| 364 | |
| 365 | typedef struct __pthread_cleanup_t { |
| 366 | struct __pthread_cleanup_t* __cleanup_prev; |
| 367 | __pthread_cleanup_func_t __cleanup_routine; |
| 368 | void* __cleanup_arg; |
| 369 | } __pthread_cleanup_t; |
| 370 | |
| 371 | void __pthread_cleanup_push(__pthread_cleanup_t* c, __pthread_cleanup_func_t, void*); |
| 372 | void __pthread_cleanup_pop(__pthread_cleanup_t*, int); |
| 373 | |
| 374 | /* Believe or not, the definitions of pthread_cleanup_push and |
| 375 | * pthread_cleanup_pop below are correct. Posix states that these |
| 376 | * can be implemented as macros that might introduce opening and |
| 377 | * closing braces, and that using setjmp/longjmp/return/break/continue |
| 378 | * between them results in undefined behavior. |
| 379 | */ |
| 380 | #define pthread_cleanup_push(routine, arg) \ |
| 381 | do { \ |
| 382 | __pthread_cleanup_t __cleanup; \ |
| 383 | __pthread_cleanup_push( &__cleanup, (routine), (arg) ); \ |
| 384 | |
| 385 | #define pthread_cleanup_pop(execute) \ |
| 386 | __pthread_cleanup_pop( &__cleanup, (execute)); \ |
| 387 | } while (0); \ |
| 388 | |
| 389 | __END_DECLS |
| 390 | |
| 391 | #endif |