| /* |
| * Copyright (C) 2017 The Android Open Source Project |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in |
| * the documentation and/or other materials provided with the |
| * distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS |
| * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE |
| * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, |
| * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS |
| * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED |
| * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, |
| * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT |
| * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
| * SUCH DAMAGE. |
| */ |
| |
| #include <pthread.h> |
| |
| #include "header_checks.h" |
| |
| static void pthread_h() { |
| MACRO(PTHREAD_BARRIER_SERIAL_THREAD); |
| |
| #if !defined(__BIONIC__) // No thread cancellation on Android. |
| MACRO(PTHREAD_CANCEL_ASYNCHRONOUS); |
| MACRO(PTHREAD_CANCEL_ENABLE); |
| MACRO(PTHREAD_CANCEL_DEFERRED); |
| MACRO(PTHREAD_CANCEL_DISABLE); |
| MACRO(PTHREAD_CANCELED); |
| #endif |
| |
| MACRO(PTHREAD_CREATE_DETACHED); |
| MACRO(PTHREAD_CREATE_JOINABLE); |
| MACRO(PTHREAD_EXPLICIT_SCHED); |
| MACRO(PTHREAD_INHERIT_SCHED); |
| MACRO(PTHREAD_MUTEX_DEFAULT); |
| MACRO(PTHREAD_MUTEX_ERRORCHECK); |
| MACRO(PTHREAD_MUTEX_NORMAL); |
| MACRO(PTHREAD_MUTEX_RECURSIVE); |
| |
| #if !defined(__BIONIC__) // No robust mutexes on Android. |
| MACRO(PTHREAD_MUTEX_ROBUST); |
| MACRO(PTHREAD_MUTEX_STALLED); |
| #endif |
| |
| MACRO(PTHREAD_ONCE_INIT); |
| |
| MACRO(PTHREAD_PRIO_INHERIT); |
| MACRO(PTHREAD_PRIO_NONE); |
| #if !defined(__BIONIC__) |
| MACRO(PTHREAD_PRIO_PROTECT); |
| #endif |
| |
| MACRO(PTHREAD_PROCESS_SHARED); |
| MACRO(PTHREAD_PROCESS_PRIVATE); |
| MACRO(PTHREAD_SCOPE_PROCESS); |
| MACRO(PTHREAD_SCOPE_SYSTEM); |
| |
| pthread_cond_t c0 = PTHREAD_COND_INITIALIZER; |
| pthread_mutex_t m0 = PTHREAD_MUTEX_INITIALIZER; |
| pthread_rwlock_t rw0 = PTHREAD_RWLOCK_INITIALIZER; |
| |
| TYPE(pthread_attr_t); |
| TYPE(pthread_barrier_t); |
| TYPE(pthread_barrierattr_t); |
| TYPE(pthread_cond_t); |
| TYPE(pthread_condattr_t); |
| TYPE(pthread_key_t); |
| TYPE(pthread_mutex_t); |
| TYPE(pthread_mutexattr_t); |
| TYPE(pthread_once_t); |
| TYPE(pthread_rwlock_t); |
| TYPE(pthread_rwlockattr_t); |
| TYPE(pthread_spinlock_t); |
| TYPE(pthread_t); |
| |
| FUNCTION(pthread_atfork, int (*f)(void (*)(void), void (*)(void), void (*)(void))); |
| FUNCTION(pthread_attr_destroy, int (*f)(pthread_attr_t*)); |
| FUNCTION(pthread_attr_getdetachstate, int (*f)(const pthread_attr_t*, int*)); |
| FUNCTION(pthread_attr_getguardsize, int (*f)(const pthread_attr_t*, size_t*)); |
| FUNCTION(pthread_attr_getinheritsched, int (*f)(const pthread_attr_t*, int*)); |
| FUNCTION(pthread_attr_getschedparam, int (*f)(const pthread_attr_t*, struct sched_param*)); |
| FUNCTION(pthread_attr_getschedpolicy, int (*f)(const pthread_attr_t*, int*)); |
| FUNCTION(pthread_attr_getscope, int (*f)(const pthread_attr_t*, int*)); |
| FUNCTION(pthread_attr_getstack, int (*f)(const pthread_attr_t*, void**, size_t*)); |
| FUNCTION(pthread_attr_getstacksize, int (*f)(const pthread_attr_t*, size_t*)); |
| FUNCTION(pthread_attr_init, int (*f)(pthread_attr_t*)); |
| FUNCTION(pthread_attr_setdetachstate, int (*f)(pthread_attr_t*, int)); |
| FUNCTION(pthread_attr_setguardsize, int (*f)(pthread_attr_t*, size_t)); |
| FUNCTION(pthread_attr_setinheritsched, int (*f)(pthread_attr_t*, int)); |
| FUNCTION(pthread_attr_setschedparam, int (*f)(pthread_attr_t*, const struct sched_param*)); |
| FUNCTION(pthread_attr_setschedpolicy, int (*f)(pthread_attr_t*, int)); |
| FUNCTION(pthread_attr_setscope, int (*f)(pthread_attr_t*, int)); |
| FUNCTION(pthread_attr_setstack, int (*f)(pthread_attr_t*, void*, size_t)); |
| FUNCTION(pthread_attr_setstacksize, int (*f)(pthread_attr_t*, size_t)); |
| FUNCTION(pthread_barrier_destroy, int (*f)(pthread_barrier_t*)); |
| FUNCTION(pthread_barrier_init, int (*f)(pthread_barrier_t*, const pthread_barrierattr_t*, unsigned)); |
| FUNCTION(pthread_barrier_wait, int (*f)(pthread_barrier_t*)); |
| FUNCTION(pthread_barrierattr_destroy, int (*f)(pthread_barrierattr_t*)); |
| FUNCTION(pthread_barrierattr_getpshared, int (*f)(const pthread_barrierattr_t*, int*)); |
| FUNCTION(pthread_barrierattr_init, int (*f)(pthread_barrierattr_t*)); |
| FUNCTION(pthread_barrierattr_setpshared, int (*f)(pthread_barrierattr_t*, int)); |
| #if !defined(__BIONIC__) // No thread cancellation on Android. |
| FUNCTION(pthread_cancel, int (*f)(pthread_t)); |
| #endif |
| FUNCTION(pthread_cond_broadcast, int (*f)(pthread_cond_t*)); |
| FUNCTION(pthread_cond_destroy, int (*f)(pthread_cond_t*)); |
| FUNCTION(pthread_cond_init, int (*f)(pthread_cond_t*, const pthread_condattr_t*)); |
| FUNCTION(pthread_cond_signal, int (*f)(pthread_cond_t*)); |
| FUNCTION(pthread_cond_timedwait, int (*f)(pthread_cond_t*, pthread_mutex_t*, const struct timespec*)); |
| FUNCTION(pthread_cond_wait, int (*f)(pthread_cond_t*, pthread_mutex_t*)); |
| FUNCTION(pthread_condattr_destroy, int (*f)(pthread_condattr_t*)); |
| FUNCTION(pthread_condattr_getclock, int (*f)(const pthread_condattr_t*, clockid_t*)); |
| FUNCTION(pthread_condattr_getpshared, int (*f)(const pthread_condattr_t*, int*)); |
| FUNCTION(pthread_condattr_init, int (*f)(pthread_condattr_t*)); |
| FUNCTION(pthread_condattr_setclock, int (*f)(pthread_condattr_t*, clockid_t)); |
| FUNCTION(pthread_condattr_setpshared, int (*f)(pthread_condattr_t*, int)); |
| FUNCTION(pthread_create, int (*f)(pthread_t*, const pthread_attr_t*, void* (*)(void*), void*)); |
| FUNCTION(pthread_detach, int (*f)(pthread_t)); |
| FUNCTION(pthread_equal, int (*f)(pthread_t, pthread_t)); |
| FUNCTION(pthread_exit, void (*f)(void*)); |
| #if !defined(__BIONIC__) // Marked obsolescent. |
| FUNCTION(pthread_getconcurrency, int (*f)(void)); |
| #endif |
| FUNCTION(pthread_getcpuclockid, int (*f)(pthread_t, clockid_t*)); |
| FUNCTION(pthread_getschedparam, int (*f)(pthread_t, int*, struct sched_param*)); |
| FUNCTION(pthread_getspecific, void* (*f)(pthread_key_t)); |
| FUNCTION(pthread_join, int (*f)(pthread_t, void**)); |
| FUNCTION(pthread_key_create, int (*f)(pthread_key_t*, void (*)(void*))); |
| FUNCTION(pthread_key_delete, int (*f)(pthread_key_t)); |
| #if !defined(__BIONIC__) // No robust mutexes on Android. |
| FUNCTION(pthread_mutex_consistent, int (*f)(pthread_mutex_t*)); |
| #endif |
| FUNCTION(pthread_mutex_destroy, int (*f)(pthread_mutex_t*)); |
| #if !defined(__BIONIC__) // No robust mutexes on Android. |
| FUNCTION(pthread_mutex_getprioceiling, int (*f)(const pthread_mutex_t*, int*)); |
| #endif |
| FUNCTION(pthread_mutex_init, int (*f)(pthread_mutex_t*, const pthread_mutexattr_t*)); |
| FUNCTION(pthread_mutex_lock, int (*f)(pthread_mutex_t*)); |
| #if !defined(__BIONIC__) // No robust mutexes on Android. |
| FUNCTION(pthread_mutex_setprioceiling, int (*f)(pthread_mutex_t*, int, int*)); |
| #endif |
| FUNCTION(pthread_mutex_timedlock, int (*f)(pthread_mutex_t*, const struct timespec*)); |
| FUNCTION(pthread_mutex_trylock, int (*f)(pthread_mutex_t*)); |
| FUNCTION(pthread_mutex_unlock, int (*f)(pthread_mutex_t*)); |
| FUNCTION(pthread_mutexattr_destroy, int (*f)(pthread_mutexattr_t*)); |
| #if !defined(__BIONIC__) // No robust mutexes on Android. |
| FUNCTION(pthread_mutexattr_getprioceiling, int (*f)(const pthread_mutexattr_t*, int*)); |
| #endif |
| FUNCTION(pthread_mutexattr_getprotocol, int (*f)(const pthread_mutexattr_t*, int*)); |
| FUNCTION(pthread_mutexattr_getpshared, int (*f)(const pthread_mutexattr_t*, int*)); |
| #if !defined(__BIONIC__) // No robust mutexes on Android. |
| FUNCTION(pthread_mutexattr_getrobust, int (*f)(const pthread_mutexattr_t*, int*)); |
| #endif |
| FUNCTION(pthread_mutexattr_gettype, int (*f)(const pthread_mutexattr_t*, int*)); |
| FUNCTION(pthread_mutexattr_init, int (*f)(pthread_mutexattr_t*)); |
| #if !defined(__BIONIC__) // No robust mutexes on Android. |
| FUNCTION(pthread_mutexattr_setprioceiling, int (*f)(pthread_mutexattr_t*, int)); |
| #endif |
| FUNCTION(pthread_mutexattr_setprotocol, int (*f)(pthread_mutexattr_t*, int)); |
| FUNCTION(pthread_mutexattr_setpshared, int (*f)(pthread_mutexattr_t*, int)); |
| #if !defined(__BIONIC__) // No robust mutexes on Android. |
| FUNCTION(pthread_mutexattr_setrobust, int (*f)(pthread_mutexattr_t*, int)); |
| #endif |
| FUNCTION(pthread_mutexattr_settype, int (*f)(pthread_mutexattr_t*, int)); |
| FUNCTION(pthread_once, int (*f)(pthread_once_t*, void (*)(void))); |
| FUNCTION(pthread_rwlock_destroy, int (*f)(pthread_rwlock_t*)); |
| FUNCTION(pthread_rwlock_init, int (*f)(pthread_rwlock_t*, const pthread_rwlockattr_t*)); |
| FUNCTION(pthread_rwlock_rdlock, int (*f)(pthread_rwlock_t*)); |
| FUNCTION(pthread_rwlock_timedrdlock, int (*f)(pthread_rwlock_t*, const struct timespec*)); |
| FUNCTION(pthread_rwlock_timedwrlock, int (*f)(pthread_rwlock_t*, const struct timespec*)); |
| FUNCTION(pthread_rwlock_tryrdlock, int (*f)(pthread_rwlock_t*)); |
| FUNCTION(pthread_rwlock_trywrlock, int (*f)(pthread_rwlock_t*)); |
| FUNCTION(pthread_rwlock_unlock, int (*f)(pthread_rwlock_t*)); |
| FUNCTION(pthread_rwlock_wrlock, int (*f)(pthread_rwlock_t*)); |
| FUNCTION(pthread_rwlockattr_destroy, int (*f)(pthread_rwlockattr_t*)); |
| FUNCTION(pthread_rwlockattr_getpshared, int (*f)(const pthread_rwlockattr_t*, int*)); |
| FUNCTION(pthread_rwlockattr_init, int (*f)(pthread_rwlockattr_t*)); |
| FUNCTION(pthread_rwlockattr_setpshared, int (*f)(pthread_rwlockattr_t*, int)); |
| FUNCTION(pthread_self, pthread_t (*f)(void)); |
| #if !defined(__BIONIC__) // No thread cancellation on Android. |
| FUNCTION(pthread_setcancelstate, int (*f)(int, int*)); |
| FUNCTION(pthread_setcanceltype, int (*f)(int, int*)); |
| #endif |
| #if !defined(__BIONIC__) // Marked obsolescent. |
| FUNCTION(pthread_setconcurrency, int (*f)(int)); |
| #endif |
| FUNCTION(pthread_setschedparam, int (*f)(pthread_t, int, const struct sched_param*)); |
| FUNCTION(pthread_setschedprio, int (*f)(pthread_t, int)); |
| FUNCTION(pthread_setspecific, int (*f)(pthread_key_t, const void*)); |
| FUNCTION(pthread_spin_destroy, int (*f)(pthread_spinlock_t*)); |
| FUNCTION(pthread_spin_init, int (*f)(pthread_spinlock_t*, int)); |
| FUNCTION(pthread_spin_lock, int (*f)(pthread_spinlock_t*)); |
| FUNCTION(pthread_spin_trylock, int (*f)(pthread_spinlock_t*)); |
| FUNCTION(pthread_spin_unlock, int (*f)(pthread_spinlock_t*)); |
| #if !defined(__BIONIC__) // No thread cancellation on Android. |
| FUNCTION(pthread_testcancel, void (*f)(void)); |
| #endif |
| |
| #if !defined(pthread_cleanup_pop) |
| #error pthread_cleanup_pop |
| #endif |
| #if !defined(pthread_cleanup_push) |
| #error pthread_cleanup_push |
| #endif |
| } |
| |
| // POSIX: "Inclusion of the <pthread.h> header shall make symbols defined in the |
| // headers <sched.h> and <time.h> visible." |
| |
| #define DO_NOT_INCLUDE_SCHED_H |
| #include "sched_h.c" |
| #define DO_NOT_INCLUDE_TIME_H |
| #include "time_h.c" |