6433ec22b1
Linker --wrap option resolves to __wrap_symbol for undefined symbol. During the compilation of host libportable.a, __HOST__ is defined to rename all portable functions to __wrap_symbol, and the real function to __real_symbol. This way libportable.a can be validated at host w/o changes of user's source code. See http://sourceware.org/binutils/docs/ld/Options.html Change-Id: Idcbe53dd642536f3dc2be85a875f95535b9dc0b1
315 lines
13 KiB
C
315 lines
13 KiB
C
/*
|
|
* Copyright 2012, The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include <portability.h>
|
|
#include <pthread.h>
|
|
#include <time.h>
|
|
#include <signal.h>
|
|
#include <signal_portable.h>
|
|
#include <errno.h>
|
|
#include <errno_portable.h>
|
|
|
|
#define PORTABLE_TAG "pthread_portable"
|
|
#include <log_portable.h>
|
|
|
|
/*
|
|
* Macros for STRIP_PARENS() which is used below in PTHREAD_WRAPPER(); cpp magic from:
|
|
* http://boost.2283326.n4.nabble.com/preprocessor-removing-parentheses-td2591973.html
|
|
*/
|
|
#define CAT(x, y) CAT_I(x, y)
|
|
#define CAT_I(x, y) x ## y
|
|
|
|
#define APPLY(macro, args) APPLY_I(macro, args)
|
|
#define APPLY_I(macro, args) macro args
|
|
|
|
#define STRIP_PARENS(x) EVAL((STRIP_PARENS_I x), x)
|
|
#define STRIP_PARENS_I(...) 1,1
|
|
|
|
#define EVAL(test, x) EVAL_I(test, x)
|
|
#define EVAL_I(test, x) MAYBE_STRIP_PARENS(TEST_ARITY test, x)
|
|
|
|
#define TEST_ARITY(...) APPLY(TEST_ARITY_I, (__VA_ARGS__, 2, 1))
|
|
#define TEST_ARITY_I(a,b,c,...) c
|
|
|
|
#define MAYBE_STRIP_PARENS(cond, x) MAYBE_STRIP_PARENS_I(cond, x)
|
|
#define MAYBE_STRIP_PARENS_I(cond, x) CAT(MAYBE_STRIP_PARENS_, cond)(x)
|
|
|
|
#define MAYBE_STRIP_PARENS_1(x) x
|
|
#define MAYBE_STRIP_PARENS_2(x) APPLY(MAYBE_STRIP_PARENS_2_I, x)
|
|
#define MAYBE_STRIP_PARENS_2_I(...) __VA_ARGS__
|
|
|
|
/*
|
|
* Call pthread function and convert return value (a native errno) to portable error number.
|
|
*/
|
|
#define PTHREAD_WRAPPER(fn, DECLARGS, CALLARGS, fmt) \
|
|
int WRAP(fn) DECLARGS \
|
|
{ \
|
|
int rv, portable_rv; \
|
|
\
|
|
ALOGV(" "); \
|
|
ALOGV("%s" fmt, __func__, STRIP_PARENS(CALLARGS)); \
|
|
rv = REAL(fn) CALLARGS; \
|
|
portable_rv = errno_ntop(rv); \
|
|
ALOGV("%s: return(portable_rv:%d); rv:%d;", __func__, \
|
|
portable_rv, rv); \
|
|
return portable_rv; \
|
|
}
|
|
|
|
PTHREAD_WRAPPER(pthread_attr_init, (pthread_attr_t *attr), (attr), "(attr:%p)");
|
|
|
|
PTHREAD_WRAPPER(pthread_attr_destroy, (pthread_attr_t *attr), (attr), "(attr:%p)");
|
|
|
|
PTHREAD_WRAPPER(pthread_attr_setdetachstate, (pthread_attr_t *attr, int state), (attr, state),
|
|
"(attr:%p, state:%d)");
|
|
|
|
PTHREAD_WRAPPER(pthread_attr_getdetachstate, (pthread_attr_t const *attr, int *state),
|
|
(attr, state), "(attr:%p, state:%p)");
|
|
|
|
PTHREAD_WRAPPER(pthread_attr_setschedpolicy, (pthread_attr_t *attr, int policy), (attr, policy),
|
|
"(attr:%p, policy:%d)");
|
|
|
|
PTHREAD_WRAPPER(pthread_attr_getschedpolicy, (pthread_attr_t const *attr, int *policy),
|
|
(attr, policy), "(attr:%p, policy:%p)");
|
|
|
|
PTHREAD_WRAPPER(pthread_attr_setschedparam,
|
|
(pthread_attr_t *attr, struct sched_param const *param), (attr, param),
|
|
"(attr:%p, param:%p)");
|
|
|
|
PTHREAD_WRAPPER(pthread_attr_getschedparam,
|
|
(pthread_attr_t const *attr, struct sched_param *param), (attr, param),
|
|
"(attr:%p, param:%p)");
|
|
|
|
PTHREAD_WRAPPER(pthread_attr_setstacksize, (pthread_attr_t *attr, size_t stack_size),
|
|
(attr, stack_size), "(attr:%p, stack_size:%d)");
|
|
|
|
PTHREAD_WRAPPER(pthread_attr_getstacksize, (pthread_attr_t const *attr, size_t *stack_size),
|
|
(attr, stack_size), "(attr:%p, stack_size:%p)");
|
|
|
|
PTHREAD_WRAPPER(pthread_attr_setstack, (pthread_attr_t *attr, void *stackaddr, size_t stack_size),
|
|
(attr, stackaddr, stack_size), "(attr:%p, stackaddr:%p, stack_size:%d)");
|
|
|
|
PTHREAD_WRAPPER(pthread_attr_getstack, (pthread_attr_t const *attr, void **stackaddr,
|
|
size_t *stack_size), (attr, stackaddr, stack_size),
|
|
"(attr:%p, stackaddr:%p stack_size:%p)");
|
|
|
|
PTHREAD_WRAPPER(pthread_attr_setguardsize, (pthread_attr_t *attr, size_t guard_size),
|
|
(attr, guard_size), "(attr:%p, guard_size:%d)");
|
|
|
|
PTHREAD_WRAPPER(pthread_attr_getguardsize, (pthread_attr_t const *attr, size_t *guard_size),
|
|
(attr, guard_size), "(attr:%p, guard_size:%p)");
|
|
|
|
PTHREAD_WRAPPER(pthread_attr_setscope, (pthread_attr_t *attr, int scope), (attr, scope),
|
|
"(attr:%p, scope:%d)");
|
|
|
|
PTHREAD_WRAPPER(pthread_attr_getscope, (pthread_attr_t const *attr), (attr), "(attr:%p)");
|
|
|
|
PTHREAD_WRAPPER(pthread_getattr_np, (pthread_t thid, pthread_attr_t *attr), (thid, attr),
|
|
"(thid:%lx, attr:%p)");
|
|
|
|
PTHREAD_WRAPPER(pthread_create, (pthread_t *thread, const pthread_attr_t *attr,
|
|
void *(*start_routine) (void *), void *arg),
|
|
(thread, attr, start_routine, arg),
|
|
"(thread:%p attr:%p, start_routine:%p, arg:%p)");
|
|
|
|
// void pthread_exit(void * retval);
|
|
PTHREAD_WRAPPER(pthread_join, (pthread_t thid, void **ret_val), (thid, ret_val),
|
|
"(thid:%lx, ret_val:%p)");
|
|
|
|
PTHREAD_WRAPPER(pthread_detach, (pthread_t thid), (thid), "(thid:%lx)");
|
|
|
|
// pthread_t pthread_self(void);
|
|
// int pthread_equal(pthread_t one, pthread_t two);
|
|
|
|
PTHREAD_WRAPPER(pthread_getschedparam, (pthread_t thid, int *policy, struct sched_param *param),
|
|
(thid, policy, param), "(thid:%lx, policy:%p, param:%p)");
|
|
|
|
PTHREAD_WRAPPER(pthread_setschedparam, (pthread_t thid, int policy,
|
|
struct sched_param const *param), (thid, policy, param),
|
|
"(thid:%lx, policy:%d, param:%p)");
|
|
|
|
PTHREAD_WRAPPER(pthread_mutexattr_init, (pthread_mutexattr_t *attr), (attr), "(attr:%p)");
|
|
|
|
PTHREAD_WRAPPER(pthread_mutexattr_destroy, (pthread_mutexattr_t *attr), (attr), "(attr:%p)");
|
|
|
|
PTHREAD_WRAPPER(pthread_mutexattr_gettype, (const pthread_mutexattr_t *attr, int *type),
|
|
(attr, type), "(attr:%p, type:%p)");
|
|
|
|
PTHREAD_WRAPPER(pthread_mutexattr_settype, (pthread_mutexattr_t *attr, int type), (attr, type),
|
|
"(attr:%p, type:%d)");
|
|
|
|
PTHREAD_WRAPPER(pthread_mutexattr_setpshared, (pthread_mutexattr_t *attr, int pshared),
|
|
(attr, pshared), "(attr:%p, pshared:%d)");
|
|
|
|
PTHREAD_WRAPPER(pthread_mutexattr_getpshared, (pthread_mutexattr_t *attr, int *pshared),
|
|
(attr, pshared), "(attr:%p, pshared:%p)");
|
|
|
|
PTHREAD_WRAPPER(pthread_mutex_init, (pthread_mutex_t *mutex, const pthread_mutexattr_t *attr),
|
|
(mutex, attr), "(mutex:%p, attr:%p)");
|
|
|
|
PTHREAD_WRAPPER(pthread_mutex_destroy, (pthread_mutex_t *mutex), (mutex), "(mutex:%p)");
|
|
|
|
PTHREAD_WRAPPER(pthread_mutex_lock, (pthread_mutex_t *mutex), (mutex), "(mutex:%p)");
|
|
|
|
PTHREAD_WRAPPER(pthread_mutex_unlock, (pthread_mutex_t *mutex), (mutex), "(mutex:%p)");
|
|
|
|
PTHREAD_WRAPPER(pthread_mutex_trylock, (pthread_mutex_t *mutex), (mutex), "(mutex:%p)");
|
|
|
|
#if 0 /* MISSING FROM BIONIC */
|
|
PTHREAD_WRAPPER(pthread_mutex_timedlock, (pthread_mutex_t *mutex, struct timespec *ts),
|
|
(mutex, ts), "(mutex:%p, ts:%p)");
|
|
#endif /* MISSING */
|
|
|
|
PTHREAD_WRAPPER(pthread_condattr_init, (pthread_condattr_t *attr), (attr), "(attr:%p)");
|
|
|
|
PTHREAD_WRAPPER(pthread_condattr_getpshared, (pthread_condattr_t *attr, int *pshared),
|
|
(attr, pshared), "(attr:%p, pshared:%p)");
|
|
|
|
PTHREAD_WRAPPER(pthread_condattr_setpshared, (pthread_condattr_t* attr, int pshared),
|
|
(attr, pshared), "(attr:%p, pshared:%d)");
|
|
|
|
PTHREAD_WRAPPER(pthread_condattr_destroy, (pthread_condattr_t *attr), (attr), "(attr:%p)");
|
|
|
|
PTHREAD_WRAPPER(pthread_cond_init, (pthread_cond_t *cond, const pthread_condattr_t *attr),
|
|
(cond, attr), "(cond:%p, attr:%p)");
|
|
|
|
PTHREAD_WRAPPER(pthread_cond_destroy, (pthread_cond_t *cond), (cond), "(cond:%p)");
|
|
|
|
PTHREAD_WRAPPER(pthread_cond_broadcast, (pthread_cond_t *cond), (cond), "(cond:%p)");
|
|
|
|
PTHREAD_WRAPPER(pthread_cond_signal, (pthread_cond_t *cond), (cond), "(cond:%p)");
|
|
|
|
PTHREAD_WRAPPER(pthread_cond_wait, (pthread_cond_t *cond, pthread_mutex_t *mutex),
|
|
(cond, mutex), "(cond:%p, mutex:%p)");
|
|
|
|
PTHREAD_WRAPPER(pthread_cond_timedwait, (pthread_cond_t *cond, pthread_mutex_t *mutex,
|
|
const struct timespec *abstime), (cond, mutex, abstime),
|
|
"(cond:%p, mutex:%p, abstime:%p)");
|
|
|
|
PTHREAD_WRAPPER(pthread_cond_timedwait_monotonic_np, (pthread_cond_t *cond,
|
|
pthread_mutex_t *mutex, const struct timespec *abstime),
|
|
(cond, mutex, abstime), "(cond:%p, mutex:%p, abstime:%p)");
|
|
|
|
PTHREAD_WRAPPER(pthread_cond_timedwait_monotonic, (pthread_cond_t *cond, pthread_mutex_t
|
|
*mutex, const struct timespec *abstime),
|
|
(cond, mutex, abstime), "(cond:%p, mutex:%p, abstime:%p)");
|
|
|
|
PTHREAD_WRAPPER(pthread_cond_timedwait_relative_np, (pthread_cond_t *cond, pthread_mutex_t *mutex,
|
|
const struct timespec *reltime), (cond, mutex, reltime),
|
|
"(cond:%p, mutex:%p, reltime:%p)");
|
|
|
|
PTHREAD_WRAPPER(pthread_cond_timeout_np, (pthread_cond_t *cond, pthread_mutex_t *mutex,
|
|
unsigned msecs), (cond, mutex, msecs), "(cond:%p, mutex:%p, msecs:%u)");
|
|
|
|
PTHREAD_WRAPPER(pthread_mutex_lock_timeout_np, (pthread_mutex_t *mutex, unsigned msecs),
|
|
(mutex, msecs), "(mutex:%p, msecs:%u)");
|
|
|
|
PTHREAD_WRAPPER(pthread_rwlockattr_init, (pthread_rwlockattr_t *attr), (attr), "(attr:%p)");
|
|
|
|
PTHREAD_WRAPPER(pthread_rwlockattr_destroy, (pthread_rwlockattr_t *attr), (attr), "(attr:%p)");
|
|
|
|
PTHREAD_WRAPPER(pthread_rwlockattr_setpshared, (pthread_rwlockattr_t *attr, int pshared),
|
|
(attr, pshared), "(attr:%p, pshared:%d)");
|
|
|
|
PTHREAD_WRAPPER(pthread_rwlockattr_getpshared, (pthread_rwlockattr_t *attr, int *pshared),
|
|
(attr, pshared), "(attr:%p, pshared:%p)");
|
|
|
|
PTHREAD_WRAPPER(pthread_rwlock_init, (pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr),
|
|
(rwlock, attr), "(rwlock:%p, attr:%p)");
|
|
|
|
PTHREAD_WRAPPER(pthread_rwlock_destroy, (pthread_rwlock_t *rwlock), (rwlock), "(rwlock:%p)");
|
|
|
|
PTHREAD_WRAPPER(pthread_rwlock_rdlock, (pthread_rwlock_t *rwlock), (rwlock), "(rwlock:%p)");
|
|
|
|
PTHREAD_WRAPPER(pthread_rwlock_tryrdlock, (pthread_rwlock_t *rwlock), (rwlock), "(rwlock:%p)");
|
|
|
|
PTHREAD_WRAPPER(pthread_rwlock_timedrdlock, (pthread_rwlock_t *rwlock,
|
|
const struct timespec *abs_timeout),
|
|
(rwlock, abs_timeout), "(rwlock:%p, abs_timeout:%p)");
|
|
|
|
PTHREAD_WRAPPER(pthread_rwlock_wrlock, (pthread_rwlock_t *rwlock), (rwlock), "(rwlock:%p)");
|
|
|
|
PTHREAD_WRAPPER(pthread_rwlock_trywrlock, (pthread_rwlock_t *rwlock), (rwlock), "(rwlock:%p)");
|
|
|
|
PTHREAD_WRAPPER(pthread_rwlock_timedwrlock, (pthread_rwlock_t *rwlock,
|
|
const struct timespec *abs_timeout), (rwlock, abs_timeout),
|
|
"(rwlock:%p, abs_timeout:%p)");
|
|
|
|
PTHREAD_WRAPPER(pthread_rwlock_unlock, (pthread_rwlock_t *rwlock), (rwlock), "(rwlock:%p)");
|
|
|
|
PTHREAD_WRAPPER(pthread_key_create, (pthread_key_t *key, void (*destructor_function)(void *)),
|
|
(key, destructor_function), "(key:%p, destructor_function:%p)");
|
|
|
|
PTHREAD_WRAPPER(pthread_key_delete , (pthread_key_t key), (key), "(key:%x)");
|
|
|
|
PTHREAD_WRAPPER(pthread_setspecific, (pthread_key_t key, const void *value), (key, value),
|
|
"(key:%x, value:%p)");
|
|
|
|
// void *pthread_getspecific(pthread_key_t key);
|
|
|
|
int WRAP(pthread_kill)(pthread_t thread, int portable_signum)
|
|
{
|
|
char *portable_signame = map_portable_signum_to_name(portable_signum);
|
|
int mips_signum;
|
|
int portable_ret, ret;
|
|
|
|
ALOGV("%s(thread:%lx, portable_signum:%d)", __func__, thread, portable_signum);
|
|
|
|
mips_signum = signum_pton(portable_signum);
|
|
|
|
if ((portable_signum != 0) && (mips_signum == 0)) {
|
|
/* A signal MIPS doesn't support; all we can do is ignore it. */
|
|
ret = 0;
|
|
} else {
|
|
ALOGV("%s: calling pthread_kill(thread:%lx, mips_signum:%d);", __func__,
|
|
thread, mips_signum);
|
|
ret = REAL(pthread_kill)(thread, mips_signum);
|
|
}
|
|
portable_ret = errno_ntop(ret);
|
|
|
|
ALOGV("%s: return portable_ret:%d; ret:%d;", __func__,
|
|
portable_ret, ret);
|
|
|
|
return portable_ret;
|
|
}
|
|
|
|
int WRAP(pthread_sigmask)(int portable_how, const sigset_portable_t *portable_sigset,
|
|
sigset_portable_t *portable_oldset)
|
|
{
|
|
int portable_ret, ret;
|
|
|
|
ALOGV(" ");
|
|
ALOGV("%s(portable_how:%d portable_sigset:%p, portable_oldset:%p)", __func__,
|
|
portable_how, portable_sigset, portable_oldset);
|
|
|
|
ret = do_sigmask(portable_how, portable_sigset, portable_oldset, pthread_sigmask, NULL);
|
|
|
|
portable_ret = errno_ntop(ret);
|
|
|
|
ALOGV("%s: return portable_ret:%d; ret:%d;", __func__,
|
|
portable_ret, ret);
|
|
|
|
return portable_ret;
|
|
}
|
|
|
|
PTHREAD_WRAPPER(pthread_getcpuclockid, (pthread_t tid, clockid_t *clockid), (tid, clockid),
|
|
"(tid:%lx, clockid:%p)");
|
|
|
|
PTHREAD_WRAPPER(pthread_once, (pthread_once_t *once_control, void (*init_routine)(void)),
|
|
(once_control, init_routine), "(once_control:%p, init_routine:%p)");
|
|
|
|
PTHREAD_WRAPPER(pthread_setname_np, (pthread_t thid, const char *thname), (thid, thname),
|
|
"(thid:%lx, thname:\"%s\")");
|