Merge "Use __BIONIC_FORTIFY_VARIADIC for variadic functions."
diff --git a/benchmarks/pthread_benchmark.cpp b/benchmarks/pthread_benchmark.cpp
index 1ad6345..46d6e64 100644
--- a/benchmarks/pthread_benchmark.cpp
+++ b/benchmarks/pthread_benchmark.cpp
@@ -96,6 +96,57 @@
}
BIONIC_BENCHMARK(BM_pthread_mutex_lock_RECURSIVE);
+#if defined(__LP64__)
+namespace {
+struct PIMutex {
+ pthread_mutex_t mutex;
+
+ PIMutex(int type) {
+ pthread_mutexattr_t attr;
+ pthread_mutexattr_init(&attr);
+ pthread_mutexattr_settype(&attr, type);
+ pthread_mutexattr_setprotocol(&attr, PTHREAD_PRIO_INHERIT);
+ pthread_mutex_init(&mutex, &attr);
+ pthread_mutexattr_destroy(&attr);
+ }
+
+ ~PIMutex() {
+ pthread_mutex_destroy(&mutex);
+ }
+};
+}
+
+static void BM_pthread_mutex_lock_PI(benchmark::State& state) {
+ PIMutex m(PTHREAD_MUTEX_NORMAL);
+
+ while (state.KeepRunning()) {
+ pthread_mutex_lock(&m.mutex);
+ pthread_mutex_unlock(&m.mutex);
+ }
+}
+BIONIC_BENCHMARK(BM_pthread_mutex_lock_PI);
+
+static void BM_pthread_mutex_lock_ERRORCHECK_PI(benchmark::State& state) {
+ PIMutex m(PTHREAD_MUTEX_ERRORCHECK);
+
+ while (state.KeepRunning()) {
+ pthread_mutex_lock(&m.mutex);
+ pthread_mutex_unlock(&m.mutex);
+ }
+}
+BIONIC_BENCHMARK(BM_pthread_mutex_lock_ERRORCHECK_PI);
+
+static void BM_pthread_mutex_lock_RECURSIVE_PI(benchmark::State& state) {
+ PIMutex m(PTHREAD_MUTEX_RECURSIVE);
+
+ while (state.KeepRunning()) {
+ pthread_mutex_lock(&m.mutex);
+ pthread_mutex_unlock(&m.mutex);
+ }
+}
+BIONIC_BENCHMARK(BM_pthread_mutex_lock_RECURSIVE_PI);
+#endif // defined(__LP64__)
+
static void BM_pthread_rwlock_read(benchmark::State& state) {
pthread_rwlock_t lock;
pthread_rwlock_init(&lock, NULL);
diff --git a/libc/bionic/bionic_futex.cpp b/libc/bionic/bionic_futex.cpp
index dd66e40..0ac1f6e 100644
--- a/libc/bionic/bionic_futex.cpp
+++ b/libc/bionic/bionic_futex.cpp
@@ -32,8 +32,9 @@
#include "private/bionic_time_conversions.h"
-int __futex_wait_ex(volatile void* ftx, bool shared, int value, bool use_realtime_clock,
- const timespec* abs_timeout) {
+static inline __always_inline int FutexWithTimeout(volatile void* ftx, int op, int value,
+ bool use_realtime_clock,
+ const timespec* abs_timeout, int bitset) {
const timespec* futex_abs_timeout = abs_timeout;
// pthread's and semaphore's default behavior is to use CLOCK_REALTIME, however this behavior is
// essentially never intended, as that clock is prone to change discontinuously.
@@ -54,6 +55,17 @@
futex_abs_timeout = &converted_monotonic_abs_timeout;
}
- return __futex(ftx, (shared ? FUTEX_WAIT_BITSET : FUTEX_WAIT_BITSET_PRIVATE), value,
- futex_abs_timeout, FUTEX_BITSET_MATCH_ANY);
+ return __futex(ftx, op, value, futex_abs_timeout, bitset);
+}
+
+int __futex_wait_ex(volatile void* ftx, bool shared, int value, bool use_realtime_clock,
+ const timespec* abs_timeout) {
+ return FutexWithTimeout(ftx, (shared ? FUTEX_WAIT_BITSET : FUTEX_WAIT_BITSET_PRIVATE), value,
+ use_realtime_clock, abs_timeout, FUTEX_BITSET_MATCH_ANY);
+}
+
+int __futex_pi_lock_ex(volatile void* ftx, bool shared, bool use_realtime_clock,
+ const timespec* abs_timeout) {
+ return FutexWithTimeout(ftx, (shared ? FUTEX_LOCK_PI : FUTEX_LOCK_PI_PRIVATE), 0,
+ use_realtime_clock, abs_timeout, 0);
}
diff --git a/libc/bionic/pthread_mutex.cpp b/libc/bionic/pthread_mutex.cpp
index 14e0ab0..ed90639 100644
--- a/libc/bionic/pthread_mutex.cpp
+++ b/libc/bionic/pthread_mutex.cpp
@@ -49,9 +49,13 @@
* bits: name description
* 0-3 type type of mutex
* 4 shared process-shared flag
+ * 5 protocol whether it is a priority inherit mutex.
*/
#define MUTEXATTR_TYPE_MASK 0x000f
#define MUTEXATTR_SHARED_MASK 0x0010
+#define MUTEXATTR_PROTOCOL_MASK 0x0020
+
+#define MUTEXATTR_PROTOCOL_SHIFT 5
int pthread_mutexattr_init(pthread_mutexattr_t *attr)
{
@@ -113,17 +117,119 @@
return 0;
}
-/* a mutex contains a state value and a owner_tid.
- * The value is implemented as a 16-bit integer holding the following fields:
- *
- * bits: name description
- * 15-14 type mutex type
- * 13 shared process-shared flag
- * 12-2 counter counter of recursive mutexes
- * 1-0 state lock state (0, 1 or 2)
- *
- * The owner_tid is used only in recursive and errorcheck mutex to hold the mutex owner thread tid.
- */
+int pthread_mutexattr_setprotocol(pthread_mutexattr_t* attr, int protocol) {
+ if (protocol != PTHREAD_PRIO_NONE && protocol != PTHREAD_PRIO_INHERIT) {
+ return EINVAL;
+ }
+ *attr = (*attr & ~MUTEXATTR_PROTOCOL_MASK) | (protocol << MUTEXATTR_PROTOCOL_SHIFT);
+ return 0;
+}
+
+int pthread_mutexattr_getprotocol(const pthread_mutexattr_t* attr, int* protocol) {
+ *protocol = (*attr & MUTEXATTR_PROTOCOL_MASK) >> MUTEXATTR_PROTOCOL_SHIFT;
+ return 0;
+}
+
+#if defined(__LP64__)
+
+// Priority Inheritance mutex implementation
+struct PIMutex {
+ // mutex type, can be 0 (normal), 1 (recursive), 2 (errorcheck), constant during lifetime
+ uint8_t type;
+ // process-shared flag, constant during lifetime
+ bool shared;
+ // <number of times a thread holding a recursive PI mutex> - 1
+ uint16_t counter;
+ // owner_tid is read/written by both userspace code and kernel code. It includes three fields:
+ // FUTEX_WAITERS, FUTEX_OWNER_DIED and FUTEX_TID_MASK.
+ atomic_int owner_tid;
+};
+
+static inline __always_inline int PIMutexTryLock(PIMutex& mutex) {
+ pid_t tid = __get_thread()->tid;
+ // Handle common case first.
+ int old_owner = 0;
+ if (__predict_true(atomic_compare_exchange_strong_explicit(&mutex.owner_tid,
+ &old_owner, tid,
+ memory_order_acquire,
+ memory_order_relaxed))) {
+ return 0;
+ }
+ if (tid == (old_owner & FUTEX_TID_MASK)) {
+ // We already own this mutex.
+ if (mutex.type == PTHREAD_MUTEX_NORMAL) {
+ return EBUSY;
+ }
+ if (mutex.type == PTHREAD_MUTEX_ERRORCHECK) {
+ return EDEADLK;
+ }
+ if (mutex.counter == 0xffff) {
+ return EAGAIN;
+ }
+ mutex.counter++;
+ return 0;
+ }
+ return EBUSY;
+}
+
+static int PIMutexTimedLock(PIMutex& mutex, const timespec* abs_timeout) {
+ int ret = PIMutexTryLock(mutex);
+ if (__predict_true(ret == 0)) {
+ return 0;
+ }
+ if (ret == EBUSY) {
+ ret = -__futex_pi_lock_ex(&mutex.owner_tid, mutex.shared, true, abs_timeout);
+ }
+ return ret;
+}
+
+static int PIMutexUnlock(PIMutex& mutex) {
+ pid_t tid = __get_thread()->tid;
+ int old_owner = tid;
+ // Handle common case first.
+ if (__predict_true(mutex.type == PTHREAD_MUTEX_NORMAL)) {
+ if (__predict_true(atomic_compare_exchange_strong_explicit(&mutex.owner_tid,
+ &old_owner, 0,
+ memory_order_release,
+ memory_order_relaxed))) {
+ return 0;
+ }
+ }
+
+ if (tid != (old_owner & FUTEX_TID_MASK)) {
+ // The mutex can only be unlocked by the thread who owns it.
+ return EPERM;
+ }
+ if (mutex.type == PTHREAD_MUTEX_RECURSIVE) {
+ if (mutex.counter != 0u) {
+ --mutex.counter;
+ return 0;
+ }
+ }
+ if (old_owner == tid) {
+ // No thread is waiting.
+ if (__predict_true(atomic_compare_exchange_strong_explicit(&mutex.owner_tid,
+ &old_owner, 0,
+ memory_order_release,
+ memory_order_relaxed))) {
+ return 0;
+ }
+ }
+ return -__futex_pi_unlock(&mutex.owner_tid, mutex.shared);
+}
+
+static int PIMutexDestroy(PIMutex& mutex) {
+ // The mutex should be in unlocked state (owner_tid == 0) when destroyed.
+ // Store 0xffffffff to make the mutex unusable.
+ int old_owner = 0;
+ if (atomic_compare_exchange_strong_explicit(&mutex.owner_tid, &old_owner, 0xffffffff,
+ memory_order_relaxed, memory_order_relaxed)) {
+ return 0;
+ }
+ return EBUSY;
+}
+#endif // defined(__LP64__)
+
/* Convenience macro, creates a mask of 'bits' bits that starts from
* the 'shift'-th least significant bit in a 32-bit word.
@@ -139,7 +245,6 @@
/* And this one does the opposite, i.e. extract a field's value from a bit pattern */
#define FIELD_FROM_BITS(val,shift,bits) (((val) >> (shift)) & ((1 << (bits))-1))
-
/* Convenience macros.
*
* These are used to form or modify the bit pattern of a given mutex value
@@ -214,13 +319,47 @@
#define MUTEX_TYPE_BITS_NORMAL MUTEX_TYPE_TO_BITS(PTHREAD_MUTEX_NORMAL)
#define MUTEX_TYPE_BITS_RECURSIVE MUTEX_TYPE_TO_BITS(PTHREAD_MUTEX_RECURSIVE)
#define MUTEX_TYPE_BITS_ERRORCHECK MUTEX_TYPE_TO_BITS(PTHREAD_MUTEX_ERRORCHECK)
+// Use a special mutex type to mark priority inheritance mutexes.
+#define MUTEX_TYPE_BITS_WITH_PI MUTEX_TYPE_TO_BITS(3)
+// For a PI mutex, it includes below fields:
+// Atomic(uint16_t) state;
+// PIMutex pi_mutex;
+//
+// state holds the following fields:
+//
+// bits: name description
+// 15-14 type mutex type, should be 3
+//
+// pi_mutex holds the state of a PI mutex.
+//
+// For a Non-PI mutex, it includes below fields:
+// Atomic(uint16_t) state;
+// atomic_int owner_tid; // Atomic(uint16_t) in 32-bit programs
+//
+// state holds the following fields:
+//
+// bits: name description
+// 15-14 type mutex type, can be 0 (normal), 1 (recursive), 2 (errorcheck)
+// 13 shared process-shared flag
+// 12-2 counter <number of times a thread holding a recursive Non-PI mutex> - 1
+// 1-0 state lock state (0, 1 or 2)
+//
+// bits 15-13 are constant during the lifetime of the mutex.
+//
+// owner_tid is used only in recursive and errorcheck Non-PI mutexes to hold the mutex owner
+// thread id.
+//
+// PI mutexes and Non-PI mutexes are distinguished by checking type field in state.
struct pthread_mutex_internal_t {
_Atomic(uint16_t) state;
#if defined(__LP64__)
uint16_t __pad;
- atomic_int owner_tid;
- char __reserved[32];
+ union {
+ atomic_int owner_tid;
+ PIMutex pi_mutex;
+ };
+ char __reserved[28];
#else
_Atomic(uint16_t) owner_tid;
#endif
@@ -267,13 +406,26 @@
return EINVAL;
}
- atomic_init(&mutex->state, state);
- atomic_init(&mutex->owner_tid, 0);
+ if (((*attr & MUTEXATTR_PROTOCOL_MASK) >> MUTEXATTR_PROTOCOL_SHIFT) == PTHREAD_PRIO_INHERIT) {
+#if defined(__LP64__)
+ atomic_init(&mutex->state, MUTEX_TYPE_BITS_WITH_PI);
+ mutex->pi_mutex.type = *attr & MUTEXATTR_TYPE_MASK;
+ mutex->pi_mutex.shared = (*attr & MUTEXATTR_SHARED_MASK) != 0;
+#else
+ return EINVAL;
+#endif
+ } else {
+ atomic_init(&mutex->state, state);
+ atomic_init(&mutex->owner_tid, 0);
+ }
return 0;
}
-static inline __always_inline int __pthread_normal_mutex_trylock(pthread_mutex_internal_t* mutex,
- uint16_t shared) {
+// namespace for Non-PI mutex routines.
+namespace NonPI {
+
+static inline __always_inline int NormalMutexTryLock(pthread_mutex_internal_t* mutex,
+ uint16_t shared) {
const uint16_t unlocked = shared | MUTEX_STATE_BITS_UNLOCKED;
const uint16_t locked_uncontended = shared | MUTEX_STATE_BITS_LOCKED_UNCONTENDED;
@@ -286,7 +438,7 @@
}
/*
- * Lock a mutex of type NORMAL.
+ * Lock a normal Non-PI mutex.
*
* As noted above, there are three states:
* 0 (unlocked, no contention)
@@ -297,11 +449,11 @@
* "type" value is zero, so the only bits that will be set are the ones in
* the lock state field.
*/
-static inline __always_inline int __pthread_normal_mutex_lock(pthread_mutex_internal_t* mutex,
- uint16_t shared,
- bool use_realtime_clock,
- const timespec* abs_timeout_or_null) {
- if (__predict_true(__pthread_normal_mutex_trylock(mutex, shared) == 0)) {
+static inline __always_inline int NormalMutexLock(pthread_mutex_internal_t* mutex,
+ uint16_t shared,
+ bool use_realtime_clock,
+ const timespec* abs_timeout_or_null) {
+ if (__predict_true(NormalMutexTryLock(mutex, shared) == 0)) {
return 0;
}
int result = check_timespec(abs_timeout_or_null, true);
@@ -333,11 +485,11 @@
}
/*
- * Release a normal mutex. The caller is responsible for determining
+ * Release a normal Non-PI mutex. The caller is responsible for determining
* that we are in fact the owner of this lock.
*/
-static inline __always_inline void __pthread_normal_mutex_unlock(pthread_mutex_internal_t* mutex,
- uint16_t shared) {
+static inline __always_inline void NormalMutexUnlock(pthread_mutex_internal_t* mutex,
+ uint16_t shared) {
const uint16_t unlocked = shared | MUTEX_STATE_BITS_UNLOCKED;
const uint16_t locked_contended = shared | MUTEX_STATE_BITS_LOCKED_CONTENDED;
@@ -370,14 +522,14 @@
}
}
-/* This common inlined function is used to increment the counter of a recursive mutex.
+/* This common inlined function is used to increment the counter of a recursive Non-PI mutex.
*
* If the counter overflows, it will return EAGAIN.
* Otherwise, it atomically increments the counter and returns 0.
*
*/
-static inline __always_inline int __recursive_increment(pthread_mutex_internal_t* mutex,
- uint16_t old_state) {
+static inline __always_inline int RecursiveIncrement(pthread_mutex_internal_t* mutex,
+ uint16_t old_state) {
// Detect recursive lock overflow and return EAGAIN.
// This is safe because only the owner thread can modify the
// counter bits in the mutex value.
@@ -387,17 +539,17 @@
// Other threads are able to change the lower bits (e.g. promoting it to "contended"),
// but the mutex counter will not overflow. So we use atomic_fetch_add operation here.
- // The mutex is still locked by current thread, so we don't need a release fence.
+ // The mutex is already locked by current thread, so we don't need an acquire fence.
atomic_fetch_add_explicit(&mutex->state, MUTEX_COUNTER_BITS_ONE, memory_order_relaxed);
return 0;
}
-static inline __always_inline int __recursive_or_errorcheck_mutex_wait(
- pthread_mutex_internal_t* mutex,
- uint16_t shared,
- uint16_t old_state,
- bool use_realtime_clock,
- const timespec* abs_timeout) {
+// Wait on a recursive or errorcheck Non-PI mutex.
+static inline __always_inline int RecursiveOrErrorcheckMutexWait(pthread_mutex_internal_t* mutex,
+ uint16_t shared,
+ uint16_t old_state,
+ bool use_realtime_clock,
+ const timespec* abs_timeout) {
// __futex_wait always waits on a 32-bit value. But state is 16-bit. For a normal mutex, the owner_tid
// field in mutex is not used. On 64-bit devices, the __pad field in mutex is not used.
// But when a recursive or errorcheck mutex is used on 32-bit devices, we need to add the
@@ -418,16 +570,16 @@
#endif
}
-static int __pthread_mutex_lock_with_timeout(pthread_mutex_internal_t* mutex,
- bool use_realtime_clock,
- const timespec* abs_timeout_or_null) {
+// Lock a Non-PI mutex.
+static int MutexLockWithTimeout(pthread_mutex_internal_t* mutex, bool use_realtime_clock,
+ const timespec* abs_timeout_or_null) {
uint16_t old_state = atomic_load_explicit(&mutex->state, memory_order_relaxed);
uint16_t mtype = (old_state & MUTEX_TYPE_MASK);
uint16_t shared = (old_state & MUTEX_SHARED_MASK);
// Handle common case first.
if ( __predict_true(mtype == MUTEX_TYPE_BITS_NORMAL) ) {
- return __pthread_normal_mutex_lock(mutex, shared, use_realtime_clock, abs_timeout_or_null);
+ return NormalMutexLock(mutex, shared, use_realtime_clock, abs_timeout_or_null);
}
// Do we already own this recursive or error-check mutex?
@@ -436,7 +588,7 @@
if (mtype == MUTEX_TYPE_BITS_ERRORCHECK) {
return EDEADLK;
}
- return __recursive_increment(mutex, old_state);
+ return RecursiveIncrement(mutex, old_state);
}
const uint16_t unlocked = mtype | shared | MUTEX_STATE_BITS_UNLOCKED;
@@ -492,14 +644,16 @@
return result;
}
// We are in locked_contended state, sleep until someone wakes us up.
- if (__recursive_or_errorcheck_mutex_wait(mutex, shared, old_state, use_realtime_clock,
- abs_timeout_or_null) == -ETIMEDOUT) {
+ if (RecursiveOrErrorcheckMutexWait(mutex, shared, old_state, use_realtime_clock,
+ abs_timeout_or_null) == -ETIMEDOUT) {
return ETIMEDOUT;
}
old_state = atomic_load_explicit(&mutex->state, memory_order_relaxed);
}
}
+} // namespace NonPI
+
int pthread_mutex_lock(pthread_mutex_t* mutex_interface) {
#if !defined(__LP64__)
// Some apps depend on being able to pass NULL as a mutex and get EINVAL
@@ -517,11 +671,16 @@
uint16_t shared = (old_state & MUTEX_SHARED_MASK);
// Avoid slowing down fast path of normal mutex lock operation.
if (__predict_true(mtype == MUTEX_TYPE_BITS_NORMAL)) {
- if (__predict_true(__pthread_normal_mutex_trylock(mutex, shared) == 0)) {
+ if (__predict_true(NonPI::NormalMutexTryLock(mutex, shared) == 0)) {
return 0;
}
}
- return __pthread_mutex_lock_with_timeout(mutex, false, nullptr);
+#if defined(__LP64__)
+ if (mtype == MUTEX_TYPE_BITS_WITH_PI) {
+ return PIMutexTimedLock(mutex->pi_mutex, nullptr);
+ }
+#endif
+ return NonPI::MutexLockWithTimeout(mutex, false, nullptr);
}
int pthread_mutex_unlock(pthread_mutex_t* mutex_interface) {
@@ -542,9 +701,14 @@
// Handle common case first.
if (__predict_true(mtype == MUTEX_TYPE_BITS_NORMAL)) {
- __pthread_normal_mutex_unlock(mutex, shared);
+ NonPI::NormalMutexUnlock(mutex, shared);
return 0;
}
+#if defined(__LP64__)
+ if (mtype == MUTEX_TYPE_BITS_WITH_PI) {
+ return PIMutexUnlock(mutex->pi_mutex);
+ }
+#endif
// Do we already own this recursive or error-check mutex?
pid_t tid = __get_thread()->tid;
@@ -582,15 +746,17 @@
uint16_t old_state = atomic_load_explicit(&mutex->state, memory_order_relaxed);
uint16_t mtype = (old_state & MUTEX_TYPE_MASK);
- uint16_t shared = (old_state & MUTEX_SHARED_MASK);
-
- const uint16_t unlocked = mtype | shared | MUTEX_STATE_BITS_UNLOCKED;
- const uint16_t locked_uncontended = mtype | shared | MUTEX_STATE_BITS_LOCKED_UNCONTENDED;
// Handle common case first.
if (__predict_true(mtype == MUTEX_TYPE_BITS_NORMAL)) {
- return __pthread_normal_mutex_trylock(mutex, shared);
+ uint16_t shared = (old_state & MUTEX_SHARED_MASK);
+ return NonPI::NormalMutexTryLock(mutex, shared);
}
+#if defined(__LP64__)
+ if (mtype == MUTEX_TYPE_BITS_WITH_PI) {
+ return PIMutexTryLock(mutex->pi_mutex);
+ }
+#endif
// Do we already own this recursive or error-check mutex?
pid_t tid = __get_thread()->tid;
@@ -598,9 +764,13 @@
if (mtype == MUTEX_TYPE_BITS_ERRORCHECK) {
return EBUSY;
}
- return __recursive_increment(mutex, old_state);
+ return NonPI::RecursiveIncrement(mutex, old_state);
}
+ uint16_t shared = (old_state & MUTEX_SHARED_MASK);
+ const uint16_t unlocked = mtype | shared | MUTEX_STATE_BITS_UNLOCKED;
+ const uint16_t locked_uncontended = mtype | shared | MUTEX_STATE_BITS_LOCKED_UNCONTENDED;
+
// Same as pthread_mutex_lock, except that we don't want to wait, and
// the only operation that can succeed is a single compare_exchange to acquire the
// lock if it is released / not owned by anyone. No need for a complex loop.
@@ -623,8 +793,8 @@
timespec_from_ms(ts, ms);
timespec abs_timeout;
absolute_timespec_from_timespec(abs_timeout, ts, CLOCK_MONOTONIC);
- int error = __pthread_mutex_lock_with_timeout(__get_internal_mutex(mutex_interface),
- false, &abs_timeout);
+ int error = NonPI::MutexLockWithTimeout(__get_internal_mutex(mutex_interface), false,
+ &abs_timeout);
if (error == ETIMEDOUT) {
error = EBUSY;
}
@@ -633,13 +803,33 @@
#endif
int pthread_mutex_timedlock(pthread_mutex_t* mutex_interface, const timespec* abs_timeout) {
- return __pthread_mutex_lock_with_timeout(__get_internal_mutex(mutex_interface),
- true, abs_timeout);
+ pthread_mutex_internal_t* mutex = __get_internal_mutex(mutex_interface);
+ uint16_t old_state = atomic_load_explicit(&mutex->state, memory_order_relaxed);
+ uint16_t mtype = (old_state & MUTEX_TYPE_MASK);
+ // Handle common case first.
+ if (__predict_true(mtype == MUTEX_TYPE_BITS_NORMAL)) {
+ uint16_t shared = (old_state & MUTEX_SHARED_MASK);
+ if (__predict_true(NonPI::NormalMutexTryLock(mutex, shared) == 0)) {
+ return 0;
+ }
+ }
+#if defined(__LP64__)
+ if (mtype == MUTEX_TYPE_BITS_WITH_PI) {
+ return PIMutexTimedLock(mutex->pi_mutex, abs_timeout);
+ }
+#endif
+ return NonPI::MutexLockWithTimeout(mutex, true, abs_timeout);
}
int pthread_mutex_destroy(pthread_mutex_t* mutex_interface) {
pthread_mutex_internal_t* mutex = __get_internal_mutex(mutex_interface);
uint16_t old_state = atomic_load_explicit(&mutex->state, memory_order_relaxed);
+#if defined(__LP64__)
+ uint16_t mtype = (old_state & MUTEX_TYPE_MASK);
+ if (mtype == MUTEX_TYPE_BITS_WITH_PI) {
+ return PIMutexDestroy(mutex->pi_mutex);
+ }
+#endif
// Store 0xffff to make the mutex unusable. Although POSIX standard says it is undefined
// behavior to destroy a locked mutex, we prefer not to change mutex->state in that situation.
if (MUTEX_STATE_BITS_IS_UNLOCKED(old_state) &&
diff --git a/libc/include/android/dlext.h b/libc/include/android/dlext.h
index c824544..2b4169e 100644
--- a/libc/include/android/dlext.h
+++ b/libc/include/android/dlext.h
@@ -23,88 +23,116 @@
#include <sys/cdefs.h>
#include <sys/types.h> /* for off64_t */
+/**
+ * \file
+ * Advanced dynamic library opening support. Most users will want to use
+ * the standard [dlopen(3)](http://man7.org/linux/man-pages/man3/dlopen.3.html)
+ * functionality in `<dlfcn.h>` instead.
+ */
+
__BEGIN_DECLS
-/* bitfield definitions for android_dlextinfo.flags */
+/** Bitfield definitions for `android_dlextinfo::flags`. */
enum {
- /* When set, the reserved_addr and reserved_size fields must point to an
+ /**
+ * When set, the `reserved_addr` and `reserved_size` fields must point to an
* already-reserved region of address space which will be used to load the
- * library if it fits. If the reserved region is not large enough, the load
- * will fail.
+ * library if it fits.
+ *
+ * If the reserved region is not large enough, loading will fail.
*/
ANDROID_DLEXT_RESERVED_ADDRESS = 0x1,
- /* As DLEXT_RESERVED_ADDRESS, but if the reserved region is not large enough,
+ /**
+ * Like `ANDROID_DLEXT_RESERVED_ADDRESS`, but if the reserved region is not large enough,
* the linker will choose an available address instead.
*/
ANDROID_DLEXT_RESERVED_ADDRESS_HINT = 0x2,
- /* When set, write the GNU RELRO section of the mapped library to relro_fd
+ /**
+ * When set, write the GNU RELRO section of the mapped library to `relro_fd`
* after relocation has been performed, to allow it to be reused by another
* process loading the same library at the same address. This implies
- * ANDROID_DLEXT_USE_RELRO.
+ * `ANDROID_DLEXT_USE_RELRO`.
+ *
+ * This is mainly useful for the system WebView implementation.
*/
ANDROID_DLEXT_WRITE_RELRO = 0x4,
- /* When set, compare the GNU RELRO section of the mapped library to relro_fd
+ /**
+ * When set, compare the GNU RELRO section of the mapped library to `relro_fd`
* after relocation has been performed, and replace any relocated pages that
* are identical with a version mapped from the file.
+ *
+ * This is mainly useful for the system WebView implementation.
*/
ANDROID_DLEXT_USE_RELRO = 0x8,
- /* Instruct dlopen to use library_fd instead of opening file by name.
+ /**
+ * Use `library_fd` instead of opening the file by name.
* The filename parameter is still used to identify the library.
*/
ANDROID_DLEXT_USE_LIBRARY_FD = 0x10,
- /* If opening a library using library_fd read it starting at library_fd_offset.
- * This flag is only valid when ANDROID_DLEXT_USE_LIBRARY_FD is set.
+ /**
+ * If opening a library using `library_fd` read it starting at `library_fd_offset`.
+ * This is mainly useful for loading a library stored within another file (such as uncompressed
+ * inside a ZIP archive).
+ * This flag is only valid when `ANDROID_DLEXT_USE_LIBRARY_FD` is set.
*/
ANDROID_DLEXT_USE_LIBRARY_FD_OFFSET = 0x20,
- /* When set, do not check if the library has already been loaded by file stat(2)s.
+ /**
+ * When set, do not use `stat(2)` to check if the library has already been loaded.
*
* This flag allows forced loading of the library in the case when for some
* reason multiple ELF files share the same filename (because the already-loaded
* library has been removed and overwritten, for example).
*
- * Note that if the library has the same dt_soname as an old one and some other
- * library has the soname in DT_NEEDED list, the first one will be used to resolve any
+ * Note that if the library has the same `DT_SONAME` as an old one and some other
+ * library has the soname in its `DT_NEEDED` list, the first one will be used to resolve any
* dependencies.
*/
ANDROID_DLEXT_FORCE_LOAD = 0x40,
- /* When set, if the minimum p_vaddr of the ELF file's PT_LOAD segments is non-zero,
+ /**
+ * When set, if the minimum `p_vaddr` of the ELF file's `PT_LOAD` segments is non-zero,
* the dynamic linker will load it at that address.
*
* This flag is for ART internal use only.
*/
ANDROID_DLEXT_FORCE_FIXED_VADDR = 0x80,
- /* Instructs dlopen to load the library at the address specified by reserved_addr.
+ /**
+ * Instructs dlopen to load the library at the address specified by reserved_addr.
*
- * The difference between ANDROID_DLEXT_LOAD_AT_FIXED_ADDRESS and ANDROID_DLEXT_RESERVED_ADDRESS
- * is that for ANDROID_DLEXT_LOAD_AT_FIXED_ADDRESS the linker reserves memory at reserved_addr
- * whereas for ANDROID_DLEXT_RESERVED_ADDRESS the linker relies on the caller to reserve the memory.
+ * The difference between `ANDROID_DLEXT_LOAD_AT_FIXED_ADDRESS` and
+ * `ANDROID_DLEXT_RESERVED_ADDRESS` is that for `ANDROID_DLEXT_LOAD_AT_FIXED_ADDRESS` the linker
+ * reserves memory at `reserved_addr` whereas for `ANDROID_DLEXT_RESERVED_ADDRESS` the linker
+ * relies on the caller to reserve the memory.
*
- * This flag can be used with ANDROID_DLEXT_FORCE_FIXED_VADDR; when ANDROID_DLEXT_FORCE_FIXED_VADDR
- * is set and load_bias is not 0 (load_bias is min(p_vaddr) of PT_LOAD segments) this flag is ignored.
- * This is implemented this way because the linker has to pick one address over the other and this
- * way is more convenient for art. Note that ANDROID_DLEXT_FORCE_FIXED_VADDR does not generate
- * an error when min(p_vaddr) is 0.
+ * This flag can be used with `ANDROID_DLEXT_FORCE_FIXED_VADDR`. When
+ * `ANDROID_DLEXT_FORCE_FIXED_VADDR` is set and `load_bias` is not 0 (`load_bias` is the
+ * minimum `p_vaddr` of all `PT_LOAD` segments) this flag is ignored because the linker has to
+ * pick one address over the other and this way is more convenient for ART.
+ * Note that `ANDROID_DLEXT_FORCE_FIXED_VADDR` does not generate an error when the minimum
+ * `p_vaddr` is 0.
*
- * Cannot be used with ANDROID_DLEXT_RESERVED_ADDRESS or ANDROID_DLEXT_RESERVED_ADDRESS_HINT.
+ * Cannot be used with `ANDROID_DLEXT_RESERVED_ADDRESS` or `ANDROID_DLEXT_RESERVED_ADDRESS_HINT`.
*
* This flag is for ART internal use only.
*/
ANDROID_DLEXT_LOAD_AT_FIXED_ADDRESS = 0x100,
- /* This flag used to load library in a different namespace. The namespace is
- * specified in library_namespace.
+ /**
+ * This flag used to load library in a different namespace. The namespace is
+ * specified in `library_namespace`.
+ *
+ * This flag is for internal use only (since there is no NDK API for namespaces).
*/
ANDROID_DLEXT_USE_NAMESPACE = 0x200,
- /* Mask of valid bits */
+ /** Mask of valid bits. */
ANDROID_DLEXT_VALID_FLAG_BITS = ANDROID_DLEXT_RESERVED_ADDRESS |
ANDROID_DLEXT_RESERVED_ADDRESS_HINT |
ANDROID_DLEXT_WRITE_RELRO |
@@ -119,19 +147,36 @@
struct android_namespace_t;
+/** Used to pass Android-specific arguments to `android_dlopen_ext`. */
typedef struct {
+ /** A bitmask of `ANDROID_DLEXT_` enum values. */
uint64_t flags;
+
+ /** Used by `ANDROID_DLEXT_RESERVED_ADDRESS` and `ANDROID_DLEXT_RESERVED_ADDRESS_HINT`. */
void* reserved_addr;
+ /** Used by `ANDROID_DLEXT_RESERVED_ADDRESS` and `ANDROID_DLEXT_RESERVED_ADDRESS_HINT`. */
size_t reserved_size;
+
+ /** Used by `ANDROID_DLEXT_WRITE_RELRO` and `ANDROID_DLEXT_USE_RELRO`. */
int relro_fd;
+
+ /** Used by `ANDROID_DLEXT_USE_LIBRARY_FD`. */
int library_fd;
+ /** Used by `ANDROID_DLEXT_USE_LIBRARY_FD_OFFSET` */
off64_t library_fd_offset;
+
+ /** Used by `ANDROID_DLEXT_USE_NAMESPACE`. */
struct android_namespace_t* library_namespace;
} android_dlextinfo;
+/**
+ * Opens the given library. The `__filename` and `__flags` arguments are
+ * the same as for [dlopen(3)](http://man7.org/linux/man-pages/man3/dlopen.3.html),
+ * with the Android-specific flags supplied via the `flags` member of `__info`.
+ */
void* android_dlopen_ext(const char* __filename, int __flags, const android_dlextinfo* __info)
__INTRODUCED_IN(21);
__END_DECLS
-#endif /* __ANDROID_DLEXT_H__ */
+#endif
diff --git a/libc/include/pthread.h b/libc/include/pthread.h
index 99515da..97f023d 100644
--- a/libc/include/pthread.h
+++ b/libc/include/pthread.h
@@ -80,6 +80,9 @@
#define PTHREAD_EXPLICIT_SCHED 0
#define PTHREAD_INHERIT_SCHED 1
+#define PTHREAD_PRIO_NONE 0
+#define PTHREAD_PRIO_INHERIT 1
+
#define PTHREAD_PROCESS_PRIVATE 0
#define PTHREAD_PROCESS_SHARED 1
@@ -145,9 +148,11 @@
int pthread_mutexattr_destroy(pthread_mutexattr_t* __attr);
int pthread_mutexattr_getpshared(const pthread_mutexattr_t* __attr, int* __shared);
int pthread_mutexattr_gettype(const pthread_mutexattr_t* __attr, int* __type);
+int pthread_mutexattr_getprotocol(const pthread_mutexattr_t* __attr, int* __protocol) __INTRODUCED_IN(28);
int pthread_mutexattr_init(pthread_mutexattr_t* __attr);
int pthread_mutexattr_setpshared(pthread_mutexattr_t* __attr, int __shared);
int pthread_mutexattr_settype(pthread_mutexattr_t* __attr, int __type);
+int pthread_mutexattr_setprotocol(pthread_mutexattr_t* __attr, int __protocol) __INTRODUCED_IN(28);
int pthread_mutex_destroy(pthread_mutex_t* __mutex);
int pthread_mutex_init(pthread_mutex_t* __mutex, const pthread_mutexattr_t* __attr);
diff --git a/libc/include/sys/ioctl.h b/libc/include/sys/ioctl.h
index 76dc1ff..b48b7f9 100644
--- a/libc/include/sys/ioctl.h
+++ b/libc/include/sys/ioctl.h
@@ -36,8 +36,6 @@
* terminal-related ioctl data structures such as struct winsize.
*/
#include <linux/termios.h>
-#include <asm/ioctls.h>
-#include <asm/termbits.h>
#include <linux/tty.h>
#include <bits/ioctl.h>
diff --git a/libc/libc.arm.map b/libc/libc.arm.map
index abab364..1ed4ec6 100644
--- a/libc/libc.arm.map
+++ b/libc/libc.arm.map
@@ -1372,6 +1372,8 @@
posix_spawnp;
pthread_attr_getinheritsched;
pthread_attr_setinheritsched;
+ pthread_mutexattr_getprotocol;
+ pthread_mutexattr_setprotocol;
pthread_setschedprio;
sethostent;
setnetent;
diff --git a/libc/libc.arm64.map b/libc/libc.arm64.map
index d464a0c..f511707 100644
--- a/libc/libc.arm64.map
+++ b/libc/libc.arm64.map
@@ -1292,6 +1292,8 @@
posix_spawnp;
pthread_attr_getinheritsched;
pthread_attr_setinheritsched;
+ pthread_mutexattr_getprotocol;
+ pthread_mutexattr_setprotocol;
pthread_setschedprio;
sethostent;
setnetent;
diff --git a/libc/libc.map.txt b/libc/libc.map.txt
index 97965ac..0960560 100644
--- a/libc/libc.map.txt
+++ b/libc/libc.map.txt
@@ -1397,6 +1397,8 @@
posix_spawnp;
pthread_attr_getinheritsched;
pthread_attr_setinheritsched;
+ pthread_mutexattr_getprotocol;
+ pthread_mutexattr_setprotocol;
pthread_setschedprio;
sethostent;
setnetent;
diff --git a/libc/libc.mips.map b/libc/libc.mips.map
index 930a1ca..1160f87 100644
--- a/libc/libc.mips.map
+++ b/libc/libc.mips.map
@@ -1356,6 +1356,8 @@
posix_spawnp;
pthread_attr_getinheritsched;
pthread_attr_setinheritsched;
+ pthread_mutexattr_getprotocol;
+ pthread_mutexattr_setprotocol;
pthread_setschedprio;
sethostent;
setnetent;
diff --git a/libc/libc.mips64.map b/libc/libc.mips64.map
index d464a0c..f511707 100644
--- a/libc/libc.mips64.map
+++ b/libc/libc.mips64.map
@@ -1292,6 +1292,8 @@
posix_spawnp;
pthread_attr_getinheritsched;
pthread_attr_setinheritsched;
+ pthread_mutexattr_getprotocol;
+ pthread_mutexattr_setprotocol;
pthread_setschedprio;
sethostent;
setnetent;
diff --git a/libc/libc.x86.map b/libc/libc.x86.map
index 27b9743..b0b4b16 100644
--- a/libc/libc.x86.map
+++ b/libc/libc.x86.map
@@ -1354,6 +1354,8 @@
posix_spawnp;
pthread_attr_getinheritsched;
pthread_attr_setinheritsched;
+ pthread_mutexattr_getprotocol;
+ pthread_mutexattr_setprotocol;
pthread_setschedprio;
sethostent;
setnetent;
diff --git a/libc/libc.x86_64.map b/libc/libc.x86_64.map
index d464a0c..f511707 100644
--- a/libc/libc.x86_64.map
+++ b/libc/libc.x86_64.map
@@ -1292,6 +1292,8 @@
posix_spawnp;
pthread_attr_getinheritsched;
pthread_attr_setinheritsched;
+ pthread_mutexattr_getprotocol;
+ pthread_mutexattr_setprotocol;
pthread_setschedprio;
sethostent;
setnetent;
diff --git a/libc/private/bionic_futex.h b/libc/private/bionic_futex.h
index 9b89131..fd68007 100644
--- a/libc/private/bionic_futex.h
+++ b/libc/private/bionic_futex.h
@@ -70,4 +70,11 @@
__LIBC_HIDDEN__ int __futex_wait_ex(volatile void* ftx, bool shared, int value,
bool use_realtime_clock, const timespec* abs_timeout);
+static inline int __futex_pi_unlock(volatile void* ftx, bool shared) {
+ return __futex(ftx, shared ? FUTEX_UNLOCK_PI : FUTEX_UNLOCK_PI_PRIVATE, 0, nullptr, 0);
+}
+
+__LIBC_HIDDEN__ int __futex_pi_lock_ex(volatile void* ftx, bool shared, bool use_realtime_clock,
+ const timespec* abs_timeout);
+
#endif /* _BIONIC_FUTEX_H */
diff --git a/libdl/libdl.arm.map b/libdl/libdl.arm.map
index 1fcfc58..7ed9503 100644
--- a/libdl/libdl.arm.map
+++ b/libdl/libdl.arm.map
@@ -41,6 +41,11 @@
__cfi_slowpath_diag;
} LIBC_N;
+LIBC_PRIVATE {
+ global:
+ android_link_namespaces_all_libs;
+} LIBC_OMR1;
+
LIBC_PLATFORM {
global:
__cfi_init;
diff --git a/libdl/libdl.arm64.map b/libdl/libdl.arm64.map
index 8d4019c..199f2e3 100644
--- a/libdl/libdl.arm64.map
+++ b/libdl/libdl.arm64.map
@@ -40,6 +40,11 @@
__cfi_slowpath_diag;
} LIBC_N;
+LIBC_PRIVATE {
+ global:
+ android_link_namespaces_all_libs;
+} LIBC_OMR1;
+
LIBC_PLATFORM {
global:
__cfi_init;
diff --git a/libdl/libdl.cpp b/libdl/libdl.cpp
index c834088..4c2415f 100644
--- a/libdl/libdl.cpp
+++ b/libdl/libdl.cpp
@@ -93,6 +93,11 @@
const char* shared_libs_sonames);
__attribute__((__weak__, visibility("default")))
+bool __loader_android_link_namespaces_all_libs(
+ struct android_namespace_t* namespace_from,
+ struct android_namespace_t* namespace_to);
+
+__attribute__((__weak__, visibility("default")))
void __loader_android_dlwarning(void* obj, void (*f)(void*, const char*));
__attribute__((__weak__, visibility("default")))
@@ -205,6 +210,12 @@
}
__attribute__((__weak__))
+bool android_link_namespaces_all_libs(struct android_namespace_t* namespace_from,
+ struct android_namespace_t* namespace_to) {
+ return __loader_android_link_namespaces_all_libs(namespace_from, namespace_to);
+}
+
+__attribute__((__weak__))
void android_dlwarning(void* obj, void (*f)(void*, const char*)) {
__loader_android_dlwarning(obj, f);
}
diff --git a/libdl/libdl.map.txt b/libdl/libdl.map.txt
index 002e9f8..579ffa7 100644
--- a/libdl/libdl.map.txt
+++ b/libdl/libdl.map.txt
@@ -40,6 +40,11 @@
__cfi_slowpath_diag;
} LIBC_N;
+LIBC_PRIVATE {
+ global:
+ android_link_namespaces_all_libs;
+} LIBC_OMR1;
+
LIBC_PLATFORM {
global:
__cfi_init;
diff --git a/libdl/libdl.mips.map b/libdl/libdl.mips.map
index 8d4019c..199f2e3 100644
--- a/libdl/libdl.mips.map
+++ b/libdl/libdl.mips.map
@@ -40,6 +40,11 @@
__cfi_slowpath_diag;
} LIBC_N;
+LIBC_PRIVATE {
+ global:
+ android_link_namespaces_all_libs;
+} LIBC_OMR1;
+
LIBC_PLATFORM {
global:
__cfi_init;
diff --git a/libdl/libdl.mips64.map b/libdl/libdl.mips64.map
index 8d4019c..199f2e3 100644
--- a/libdl/libdl.mips64.map
+++ b/libdl/libdl.mips64.map
@@ -40,6 +40,11 @@
__cfi_slowpath_diag;
} LIBC_N;
+LIBC_PRIVATE {
+ global:
+ android_link_namespaces_all_libs;
+} LIBC_OMR1;
+
LIBC_PLATFORM {
global:
__cfi_init;
diff --git a/libdl/libdl.x86.map b/libdl/libdl.x86.map
index 8d4019c..199f2e3 100644
--- a/libdl/libdl.x86.map
+++ b/libdl/libdl.x86.map
@@ -40,6 +40,11 @@
__cfi_slowpath_diag;
} LIBC_N;
+LIBC_PRIVATE {
+ global:
+ android_link_namespaces_all_libs;
+} LIBC_OMR1;
+
LIBC_PLATFORM {
global:
__cfi_init;
diff --git a/libdl/libdl.x86_64.map b/libdl/libdl.x86_64.map
index 8d4019c..199f2e3 100644
--- a/libdl/libdl.x86_64.map
+++ b/libdl/libdl.x86_64.map
@@ -40,6 +40,11 @@
__cfi_slowpath_diag;
} LIBC_N;
+LIBC_PRIVATE {
+ global:
+ android_link_namespaces_all_libs;
+} LIBC_OMR1;
+
LIBC_PLATFORM {
global:
__cfi_init;
diff --git a/linker/dlfcn.cpp b/linker/dlfcn.cpp
index 7f40f90..4b84537 100644
--- a/linker/dlfcn.cpp
+++ b/linker/dlfcn.cpp
@@ -65,6 +65,8 @@
bool __loader_android_link_namespaces(android_namespace_t* namespace_from,
android_namespace_t* namespace_to,
const char* shared_libs_sonames) __LINKER_PUBLIC__;
+bool __loader_android_link_namespaces_all_libs(android_namespace_t* namespace_from,
+ android_namespace_t* namespace_to) __LINKER_PUBLIC__;
void __loader_android_set_application_target_sdk_version(uint32_t target) __LINKER_PUBLIC__;
void __loader_android_update_LD_LIBRARY_PATH(const char* ld_library_path) __LINKER_PUBLIC__;
void __loader_cfi_fail(uint64_t CallSiteTypeId,
@@ -266,6 +268,19 @@
return success;
}
+bool __loader_android_link_namespaces_all_libs(android_namespace_t* namespace_from,
+ android_namespace_t* namespace_to) {
+ ScopedPthreadMutexLocker locker(&g_dl_mutex);
+
+ bool success = link_namespaces_all_libs(namespace_from, namespace_to);
+
+ if (!success) {
+ __bionic_format_dlerror("android_link_namespaces_all_libs failed", linker_get_error_buffer());
+ }
+
+ return success;
+}
+
android_namespace_t* __loader_android_get_exported_namespace(const char* name) {
return get_exported_namespace(name);
}
diff --git a/linker/ld_android.cpp b/linker/ld_android.cpp
index c4ce1b9..4a05772 100644
--- a/linker/ld_android.cpp
+++ b/linker/ld_android.cpp
@@ -49,6 +49,7 @@
__strong_alias(__loader_android_get_exported_namespace, __internal_linker_error);
__strong_alias(__loader_android_init_anonymous_namespace, __internal_linker_error);
__strong_alias(__loader_android_link_namespaces, __internal_linker_error);
+__strong_alias(__loader_android_link_namespaces_all_libs, __internal_linker_error);
__strong_alias(__loader_android_set_application_target_sdk_version, __internal_linker_error);
__strong_alias(__loader_android_update_LD_LIBRARY_PATH, __internal_linker_error);
__strong_alias(__loader_cfi_fail, __internal_linker_error);
diff --git a/linker/linker.arm.map b/linker/linker.arm.map
index 4a3f177..a58e7c8 100644
--- a/linker/linker.arm.map
+++ b/linker/linker.arm.map
@@ -17,6 +17,7 @@
__loader_android_dlwarning;
__loader_cfi_fail;
__loader_android_link_namespaces;
+ __loader_android_link_namespaces_all_libs;
__loader_android_get_exported_namespace;
__loader_dl_unwind_find_exidx;
__loader_add_thread_local_dtor;
diff --git a/linker/linker.cpp b/linker/linker.cpp
index 05efc55..0b8d5ee 100644
--- a/linker/linker.cpp
+++ b/linker/linker.cpp
@@ -1430,7 +1430,7 @@
}
// returning true with empty soinfo means that the library is okay to be
- // loaded in the namespace buy has not yet been loaded there before.
+ // loaded in the namespace but has not yet been loaded there before.
task->set_soinfo(nullptr);
return true;
}
@@ -2363,7 +2363,8 @@
add_soinfos_to_namespace(parent_namespace->soinfo_list(), ns);
// and copy parent namespace links
for (auto& link : parent_namespace->linked_namespaces()) {
- ns->add_linked_namespace(link.linked_namespace(), link.shared_lib_sonames());
+ ns->add_linked_namespace(link.linked_namespace(), link.shared_lib_sonames(),
+ link.allow_all_shared_libs());
}
} else {
// If not shared - copy only the shared group
@@ -2399,7 +2400,25 @@
std::unordered_set<std::string> sonames_set(sonames.begin(), sonames.end());
ProtectedDataGuard guard;
- namespace_from->add_linked_namespace(namespace_to, sonames_set);
+ namespace_from->add_linked_namespace(namespace_to, sonames_set, false);
+
+ return true;
+}
+
+bool link_namespaces_all_libs(android_namespace_t* namespace_from,
+ android_namespace_t* namespace_to) {
+ if (namespace_from == nullptr) {
+ DL_ERR("error linking namespaces: namespace_from is null.");
+ return false;
+ }
+
+ if (namespace_to == nullptr) {
+ DL_ERR("error linking namespaces: namespace_to is null.");
+ return false;
+ }
+
+ ProtectedDataGuard guard;
+ namespace_from->add_linked_namespace(namespace_to, std::unordered_set<std::string>(), true);
return true;
}
@@ -3763,7 +3782,11 @@
auto it_to = namespaces.find(ns_link.ns_name());
CHECK(it_to != namespaces.end());
android_namespace_t* namespace_to = it_to->second;
- link_namespaces(namespace_from, namespace_to, ns_link.shared_libs().c_str());
+ if (ns_link.allow_all_shared_libs()) {
+ link_namespaces_all_libs(namespace_from, namespace_to);
+ } else {
+ link_namespaces(namespace_from, namespace_to, ns_link.shared_libs().c_str());
+ }
}
}
// we can no longer rely on the fact that libdl.so is part of default namespace
diff --git a/linker/linker.generic.map b/linker/linker.generic.map
index 04f4c8a..45bb0b5 100644
--- a/linker/linker.generic.map
+++ b/linker/linker.generic.map
@@ -17,6 +17,7 @@
__loader_android_dlwarning;
__loader_cfi_fail;
__loader_android_link_namespaces;
+ __loader_android_link_namespaces_all_libs;
__loader_android_get_exported_namespace;
__loader_add_thread_local_dtor;
__loader_remove_thread_local_dtor;
diff --git a/linker/linker.h b/linker/linker.h
index 6ebca4c..29d40fa 100644
--- a/linker/linker.h
+++ b/linker/linker.h
@@ -180,6 +180,9 @@
android_namespace_t* namespace_to,
const char* shared_lib_sonames);
+bool link_namespaces_all_libs(android_namespace_t* namespace_from,
+ android_namespace_t* namespace_to);
+
android_namespace_t* get_exported_namespace(const char* name);
void increment_dso_handle_reference_counter(void* dso_handle);
diff --git a/linker/linker_config.cpp b/linker/linker_config.cpp
index 60b7ad9..83c2f36 100644
--- a/linker/linker_config.cpp
+++ b/linker/linker_config.cpp
@@ -489,12 +489,15 @@
return false;
}
+ bool allow_all_shared_libs = properties.get_bool(property_name_prefix + ".link." +
+ linked_ns_name + ".allow_all_shared_libs");
+
std::string shared_libs = properties.get_string(property_name_prefix +
".link." +
linked_ns_name +
".shared_libs", &lineno);
- if (shared_libs.empty()) {
+ if (!allow_all_shared_libs && shared_libs.empty()) {
*error_msg = create_error_msg(ld_config_file_path,
lineno,
std::string("list of shared_libs for ") +
@@ -505,7 +508,15 @@
return false;
}
- ns_config->add_namespace_link(linked_ns_name, shared_libs);
+ if (allow_all_shared_libs && !shared_libs.empty()) {
+ *error_msg = create_error_msg(ld_config_file_path, lineno,
+ std::string("both shared_libs and allow_all_shared_libs "
+ "are set for ") +
+ name + "->" + linked_ns_name + " link.");
+ return false;
+ }
+
+ ns_config->add_namespace_link(linked_ns_name, shared_libs, allow_all_shared_libs);
}
ns_config->set_isolated(properties.get_bool(property_name_prefix + ".isolated"));
diff --git a/linker/linker_config.h b/linker/linker_config.h
index dde9362..0c50d57 100644
--- a/linker/linker_config.h
+++ b/linker/linker_config.h
@@ -43,8 +43,10 @@
class NamespaceLinkConfig {
public:
NamespaceLinkConfig() = default;
- NamespaceLinkConfig(const std::string& ns_name, const std::string& shared_libs)
- : ns_name_(ns_name), shared_libs_(shared_libs) {}
+ NamespaceLinkConfig(const std::string& ns_name, const std::string& shared_libs,
+ bool allow_all_shared_libs)
+ : ns_name_(ns_name), shared_libs_(shared_libs),
+ allow_all_shared_libs_(allow_all_shared_libs) {}
const std::string& ns_name() const {
return ns_name_;
@@ -54,9 +56,14 @@
return shared_libs_;
}
+ bool allow_all_shared_libs() const {
+ return allow_all_shared_libs_;
+ }
+
private:
std::string ns_name_;
std::string shared_libs_;
+ bool allow_all_shared_libs_;
};
class NamespaceConfig {
@@ -89,8 +96,9 @@
return namespace_links_;
}
- void add_namespace_link(const std::string& ns_name, const std::string& shared_libs) {
- namespace_links_.push_back(NamespaceLinkConfig(ns_name, shared_libs));
+ void add_namespace_link(const std::string& ns_name, const std::string& shared_libs,
+ bool allow_all_shared_libs) {
+ namespace_links_.push_back(NamespaceLinkConfig(ns_name, shared_libs, allow_all_shared_libs));
}
void set_isolated(bool isolated) {
diff --git a/linker/linker_namespaces.h b/linker/linker_namespaces.h
index 16906d6..a7fe0d5 100644
--- a/linker/linker_namespaces.h
+++ b/linker/linker_namespaces.h
@@ -40,8 +40,10 @@
struct android_namespace_link_t {
public:
android_namespace_link_t(android_namespace_t* linked_namespace,
- const std::unordered_set<std::string>& shared_lib_sonames)
- : linked_namespace_(linked_namespace), shared_lib_sonames_(shared_lib_sonames)
+ const std::unordered_set<std::string>& shared_lib_sonames,
+ bool allow_all_shared_libs)
+ : linked_namespace_(linked_namespace), shared_lib_sonames_(shared_lib_sonames),
+ allow_all_shared_libs_(allow_all_shared_libs)
{}
android_namespace_t* linked_namespace() const {
@@ -53,12 +55,17 @@
}
bool is_accessible(const char* soname) const {
- return shared_lib_sonames_.find(soname) != shared_lib_sonames_.end();
+ return allow_all_shared_libs_ || shared_lib_sonames_.find(soname) != shared_lib_sonames_.end();
+ }
+
+ bool allow_all_shared_libs() const {
+ return allow_all_shared_libs_;
}
private:
android_namespace_t* const linked_namespace_;
const std::unordered_set<std::string> shared_lib_sonames_;
+ bool allow_all_shared_libs_;
};
struct android_namespace_t {
@@ -105,8 +112,10 @@
return linked_namespaces_;
}
void add_linked_namespace(android_namespace_t* linked_namespace,
- const std::unordered_set<std::string>& shared_lib_sonames) {
- linked_namespaces_.push_back(android_namespace_link_t(linked_namespace, shared_lib_sonames));
+ const std::unordered_set<std::string>& shared_lib_sonames,
+ bool allow_all_shared_libs) {
+ linked_namespaces_.push_back(
+ android_namespace_link_t(linked_namespace, shared_lib_sonames, allow_all_shared_libs));
}
void add_soinfo(soinfo* si) {
diff --git a/linker/tests/linker_config_test.cpp b/linker/tests/linker_config_test.cpp
index 4c0dcdd..e716879 100644
--- a/linker/tests/linker_config_test.cpp
+++ b/linker/tests/linker_config_test.cpp
@@ -81,6 +81,8 @@
"namespace.vndk.search.paths = /system/${LIB}/vndk\n"
"namespace.vndk.asan.search.paths = /data\n"
"namespace.vndk.asan.search.paths += /system/${LIB}/vndk\n"
+ "namespace.vndk.links = default\n"
+ "namespace.vndk.link.default.allow_all_shared_libs = true\n"
"\n";
static bool write_version(const std::string& path, uint32_t version) {
@@ -154,10 +156,14 @@
const auto& default_ns_links = default_ns_config->links();
ASSERT_EQ(2U, default_ns_links.size());
+
ASSERT_EQ("system", default_ns_links[0].ns_name());
ASSERT_EQ("libc.so:libm.so:libdl.so:libstdc++.so", default_ns_links[0].shared_libs());
+ ASSERT_FALSE(default_ns_links[0].allow_all_shared_libs());
+
ASSERT_EQ("vndk", default_ns_links[1].ns_name());
ASSERT_EQ("libcutils.so:libbase.so", default_ns_links[1].shared_libs());
+ ASSERT_FALSE(default_ns_links[1].allow_all_shared_libs());
auto& ns_configs = config->namespace_configs();
ASSERT_EQ(3U, ns_configs.size());
@@ -187,8 +193,13 @@
ASSERT_TRUE(ns_vndk != nullptr) << "vndk namespace was not found";
ASSERT_FALSE(ns_vndk->isolated()); // malformed bool property
- ASSERT_FALSE(ns_vndk->visible()); // undefined bool property
+ ASSERT_FALSE(ns_vndk->visible()); // undefined bool property
ASSERT_EQ(kExpectedVndkSearchPath, ns_vndk->search_paths());
+
+ const auto& ns_vndk_links = ns_vndk->links();
+ ASSERT_EQ(1U, ns_vndk_links.size());
+ ASSERT_EQ("default", ns_vndk_links[0].ns_name());
+ ASSERT_TRUE(ns_vndk_links[0].allow_all_shared_libs());
}
TEST(linker_config, smoke) {
@@ -198,3 +209,40 @@
TEST(linker_config, asan_smoke) {
run_linker_config_smoke_test(true);
}
+
+TEST(linker_config, ns_link_shared_libs_invalid_settings) {
+ // This unit test ensures an error is emitted when a namespace link in ld.config.txt specifies
+ // both shared_libs and allow_all_shared_libs.
+
+ static const char config_str[] =
+ "dir.test = /data/local/tmp\n"
+ "\n"
+ "[test]\n"
+ "additional.namespaces = system\n"
+ "namespace.default.links = system\n"
+ "namespace.default.link.system.shared_libs = libc.so:libm.so\n"
+ "namespace.default.link.system.allow_all_shared_libs = true\n"
+ "\n";
+
+ TemporaryFile tmp_file;
+ close(tmp_file.fd);
+ tmp_file.fd = -1;
+
+ android::base::WriteStringToFile(config_str, tmp_file.path);
+
+ TemporaryDir tmp_dir;
+
+ std::string executable_path = std::string(tmp_dir.path) + "/some-binary";
+
+ const Config* config = nullptr;
+ std::string error_msg;
+ ASSERT_FALSE(Config::read_binary_config(tmp_file.path,
+ executable_path.c_str(),
+ false,
+ &config,
+ &error_msg));
+ ASSERT_TRUE(config == nullptr);
+ ASSERT_EQ(std::string(tmp_file.path) + ":6: "
+ "error: both shared_libs and allow_all_shared_libs are set for default->system link.",
+ error_msg);
+}
diff --git a/tests/Android.bp b/tests/Android.bp
index c1e455d..1521b73 100644
--- a/tests/Android.bp
+++ b/tests/Android.bp
@@ -554,6 +554,10 @@
"libnstest_root",
"libnstest_public",
"libnstest_public_internal",
+ "libnstest_ns_a_public1",
+ "libnstest_ns_a_public1_internal",
+ "libnstest_ns_b_public2",
+ "libnstest_ns_b_public3",
],
}
diff --git a/tests/dlext_private.h b/tests/dlext_private.h
index dea92ee..2621a68 100644
--- a/tests/dlext_private.h
+++ b/tests/dlext_private.h
@@ -95,6 +95,9 @@
android_namespace_t* to,
const char* shared_libs_sonames);
+extern bool android_link_namespaces_all_libs(android_namespace_t* from,
+ android_namespace_t* to);
+
extern void android_set_application_target_sdk_version(uint32_t target);
__END_DECLS
diff --git a/tests/dlext_test.cpp b/tests/dlext_test.cpp
index 64cfa08..bb2d8a3 100644
--- a/tests/dlext_test.cpp
+++ b/tests/dlext_test.cpp
@@ -1737,6 +1737,123 @@
ASSERT_EQ(expected_dlerror, dlerror());
}
+TEST(dlext, ns_link_namespaces_invalid_arguments) {
+ ASSERT_TRUE(android_init_anonymous_namespace(g_core_shared_libs.c_str(), nullptr));
+
+ android_namespace_t* ns =
+ android_create_namespace("private",
+ nullptr,
+ (get_testlib_root() + "/private_namespace_libs").c_str(),
+ ANDROID_NAMESPACE_TYPE_REGULAR,
+ nullptr,
+ nullptr);
+ ASSERT_TRUE(ns != nullptr) << dlerror();
+
+ // Test android_link_namespaces()
+ ASSERT_FALSE(android_link_namespaces(nullptr, nullptr, "libc.so"));
+ ASSERT_STREQ("android_link_namespaces failed: error linking namespaces: namespace_from is null.",
+ dlerror());
+
+ ASSERT_FALSE(android_link_namespaces(ns, nullptr, nullptr));
+ ASSERT_STREQ("android_link_namespaces failed: "
+ "error linking namespaces \"private\"->\"(default)\": "
+ "the list of shared libraries is empty.", dlerror());
+
+ ASSERT_FALSE(android_link_namespaces(ns, nullptr, ""));
+ ASSERT_STREQ("android_link_namespaces failed: "
+ "error linking namespaces \"private\"->\"(default)\": "
+ "the list of shared libraries is empty.", dlerror());
+
+ // Test android_link_namespaces_all_libs()
+ ASSERT_FALSE(android_link_namespaces_all_libs(nullptr, nullptr));
+ ASSERT_STREQ("android_link_namespaces_all_libs failed: "
+ "error linking namespaces: namespace_from is null.", dlerror());
+
+ ASSERT_FALSE(android_link_namespaces_all_libs(nullptr, ns));
+ ASSERT_STREQ("android_link_namespaces_all_libs failed: "
+ "error linking namespaces: namespace_from is null.", dlerror());
+
+ ASSERT_FALSE(android_link_namespaces_all_libs(ns, nullptr));
+ ASSERT_STREQ("android_link_namespaces_all_libs failed: "
+ "error linking namespaces: namespace_to is null.", dlerror());
+}
+
+TEST(dlext, ns_allow_all_shared_libs) {
+ ASSERT_TRUE(android_init_anonymous_namespace(g_core_shared_libs.c_str(), nullptr));
+
+ android_namespace_t* ns_a =
+ android_create_namespace("ns_a",
+ nullptr,
+ (get_testlib_root() + "/ns_a").c_str(),
+ ANDROID_NAMESPACE_TYPE_ISOLATED,
+ nullptr,
+ nullptr);
+ ASSERT_TRUE(ns_a != nullptr) << dlerror();
+ ASSERT_TRUE(android_link_namespaces(ns_a, nullptr, g_core_shared_libs.c_str())) << dlerror();
+
+ android_namespace_t* ns_b =
+ android_create_namespace("ns_b",
+ nullptr,
+ (get_testlib_root() + "/ns_b").c_str(),
+ ANDROID_NAMESPACE_TYPE_ISOLATED,
+ nullptr,
+ nullptr);
+ ASSERT_TRUE(ns_b != nullptr) << dlerror();
+ ASSERT_TRUE(android_link_namespaces(ns_b, nullptr, g_core_shared_libs.c_str())) << dlerror();
+
+ ASSERT_TRUE(android_link_namespaces(ns_b, ns_a, "libnstest_ns_a_public1.so")) << dlerror();
+ ASSERT_TRUE(android_link_namespaces_all_libs(ns_a, ns_b)) << dlerror();
+
+ // Load libs with android_dlopen_ext() from namespace b
+ android_dlextinfo extinfo;
+ extinfo.flags = ANDROID_DLEXT_USE_NAMESPACE;
+ extinfo.library_namespace = ns_b;
+
+ void* ns_b_handle1 = android_dlopen_ext("libnstest_ns_a_public1.so", RTLD_NOW, &extinfo);
+ ASSERT_TRUE(ns_b_handle1 != nullptr) << dlerror();
+
+ void* ns_b_handle1_internal =
+ android_dlopen_ext("libnstest_ns_a_public1_internal.so", RTLD_NOW, &extinfo);
+ ASSERT_TRUE(ns_b_handle1_internal == nullptr);
+
+ void* ns_b_handle2 = android_dlopen_ext("libnstest_ns_b_public2.so", RTLD_NOW, &extinfo);
+ ASSERT_TRUE(ns_b_handle2 != nullptr) << dlerror();
+
+ void* ns_b_handle3 = android_dlopen_ext("libnstest_ns_b_public3.so", RTLD_NOW, &extinfo);
+ ASSERT_TRUE(ns_b_handle3 != nullptr) << dlerror();
+
+ // Load libs with android_dlopen_ext() from namespace a
+ extinfo.library_namespace = ns_a;
+
+ void* ns_a_handle1 = android_dlopen_ext("libnstest_ns_a_public1.so", RTLD_NOW, &extinfo);
+ ASSERT_TRUE(ns_a_handle1 != nullptr) << dlerror();
+
+ void* ns_a_handle1_internal =
+ android_dlopen_ext("libnstest_ns_a_public1_internal.so", RTLD_NOW, &extinfo);
+ ASSERT_TRUE(ns_a_handle1_internal != nullptr) << dlerror();
+
+ void* ns_a_handle2 = android_dlopen_ext("libnstest_ns_b_public2.so", RTLD_NOW, &extinfo);
+ ASSERT_TRUE(ns_a_handle2 != nullptr) << dlerror();
+
+ void* ns_a_handle3 = android_dlopen_ext("libnstest_ns_b_public3.so", RTLD_NOW, &extinfo);
+ ASSERT_TRUE(ns_a_handle3 != nullptr) << dlerror();
+
+ // Compare the dlopen handle
+ ASSERT_EQ(ns_b_handle1, ns_a_handle1);
+ ASSERT_EQ(ns_b_handle2, ns_a_handle2);
+ ASSERT_EQ(ns_b_handle3, ns_a_handle3);
+
+ // Close libs
+ dlclose(ns_b_handle1);
+ dlclose(ns_b_handle2);
+ dlclose(ns_b_handle3);
+
+ dlclose(ns_a_handle1);
+ dlclose(ns_a_handle1_internal);
+ dlclose(ns_a_handle2);
+ dlclose(ns_a_handle3);
+}
+
TEST(dlext, ns_anonymous) {
static const char* root_lib = "libnstest_root.so";
std::string shared_libs = g_core_shared_libs + ":" + g_public_lib;
diff --git a/tests/libs/Android.bp b/tests/libs/Android.bp
index 61a837f..cae30b5 100644
--- a/tests/libs/Android.bp
+++ b/tests/libs/Android.bp
@@ -259,6 +259,58 @@
}
// -----------------------------------------------------------------------------
+// Build test helper libraries for linker namespaces for allow all shared libs
+//
+// This set of libraries is used to verify linker namespaces for allow all
+// shared libs.
+//
+// Test cases
+// 1. Check that namespace a exposes libnstest_ns_a_public1 to
+// namespace b while keeping libnstest_ns_a_public1_internal as an
+// internal lib.
+// 2. Check that namespace b exposes all libraries to namespace a.
+//
+// Dependency tree (visibility)
+// libnstest_ns_b_public2.so (ns:b)
+// +-> libnstest_ns_a_public1.so (ns:a)
+// +-> libnstest_ns_a_public2_internal.so (ns:a)
+// +-> libnstest_ns_b_public3.so (ns:b)
+//
+// -----------------------------------------------------------------------------
+cc_test_library {
+ name: "libnstest_ns_a_public1",
+ defaults: ["bionic_testlib_defaults"],
+ srcs: ["libnstest_ns_a_public1.cpp"],
+ relative_install_path: "bionic-loader-test-libs/ns_a",
+ shared_libs: [
+ "libnstest_ns_a_public1_internal",
+ "libnstest_ns_b_public3",
+ ],
+}
+
+cc_test_library {
+ name: "libnstest_ns_a_public1_internal",
+ defaults: ["bionic_testlib_defaults"],
+ srcs: ["libnstest_ns_a_public1_internal.cpp"],
+ relative_install_path: "bionic-loader-test-libs/ns_a",
+}
+
+cc_test_library {
+ name: "libnstest_ns_b_public2",
+ defaults: ["bionic_testlib_defaults"],
+ srcs: ["libnstest_ns_b_public2.cpp"],
+ relative_install_path: "bionic-loader-test-libs/ns_b",
+ shared_libs: ["libnstest_ns_a_public1"],
+}
+
+cc_test_library {
+ name: "libnstest_ns_b_public3",
+ defaults: ["bionic_testlib_defaults"],
+ srcs: ["libnstest_ns_b_public3.cpp"],
+ relative_install_path: "bionic-loader-test-libs/ns_b",
+}
+
+// -----------------------------------------------------------------------------
// Build DT_RUNPATH test helper libraries
// -----------------------------------------------------------------------------
// include $(LOCAL_PATH)/Android.build.dt_runpath.mk
diff --git a/tests/libs/libnstest_ns_a_public1.cpp b/tests/libs/libnstest_ns_a_public1.cpp
new file mode 100644
index 0000000..c095e60
--- /dev/null
+++ b/tests/libs/libnstest_ns_a_public1.cpp
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2018 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.
+ */
+
+static const char ns_a_public1_string[] = "libnstest_ns_a_public1.so";
+
+extern "C" const char* get_ns_a_public1_string() {
+ return ns_a_public1_string;
+}
+
+
+extern "C" const char *get_ns_a_public1_internal_string();
+
+extern "C" const char *delegate_get_ns_a_public1_internal_string() {
+ return get_ns_a_public1_internal_string();
+}
+
+
+extern "C" const char *get_ns_b_public3_string();
+
+extern "C" const char *delegate_get_ns_b_public3_string() {
+ return get_ns_b_public3_string();
+}
diff --git a/tests/libs/libnstest_ns_a_public1_internal.cpp b/tests/libs/libnstest_ns_a_public1_internal.cpp
new file mode 100644
index 0000000..6529936
--- /dev/null
+++ b/tests/libs/libnstest_ns_a_public1_internal.cpp
@@ -0,0 +1,21 @@
+/*
+ * Copyright (C) 2018 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.
+ */
+
+static const char ns_a_public1_internal_string[] = "libnstest_ns_a_public1_internal.so";
+
+extern "C" const char* get_ns_a_public1_internal_string() {
+ return ns_a_public1_internal_string;
+}
diff --git a/tests/libs/libnstest_ns_b_public2.cpp b/tests/libs/libnstest_ns_b_public2.cpp
new file mode 100644
index 0000000..6251a8d
--- /dev/null
+++ b/tests/libs/libnstest_ns_b_public2.cpp
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2018 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.
+ */
+
+static const char ns_b_public2_string[] = "libnstest_ns_b_public2.so";
+
+extern "C" const char* get_ns_b_public2_string() {
+ return ns_b_public2_string;
+}
+
+
+extern "C" const char* get_ns_a_public1_string();
+
+extern "C" const char* delegate_get_ns_a_public1_string() {
+ return get_ns_a_public1_string();
+}
diff --git a/tests/libs/libnstest_ns_b_public3.cpp b/tests/libs/libnstest_ns_b_public3.cpp
new file mode 100644
index 0000000..b332445
--- /dev/null
+++ b/tests/libs/libnstest_ns_b_public3.cpp
@@ -0,0 +1,21 @@
+/*
+ * Copyright (C) 2018 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.
+ */
+
+static const char ns_b_public3_string[] = "libnstest_ns_b_public3.so";
+
+extern "C" const char* get_ns_b_public3_string() {
+ return ns_b_public3_string;
+}
diff --git a/tests/pthread_test.cpp b/tests/pthread_test.cpp
index 183312d..9ecb10c 100644
--- a/tests/pthread_test.cpp
+++ b/tests/pthread_test.cpp
@@ -33,7 +33,9 @@
#include <atomic>
#include <vector>
+#include <android-base/parseint.h>
#include <android-base/scopeguard.h>
+#include <android-base/strings.h>
#include "private/bionic_constants.h"
#include "private/bionic_macros.h"
@@ -1631,11 +1633,27 @@
ASSERT_EQ(0, pthread_mutexattr_destroy(&attr));
}
+TEST(pthread, pthread_mutexattr_protocol) {
+ pthread_mutexattr_t attr;
+ ASSERT_EQ(0, pthread_mutexattr_init(&attr));
+
+ int protocol;
+ ASSERT_EQ(0, pthread_mutexattr_getprotocol(&attr, &protocol));
+ ASSERT_EQ(PTHREAD_PRIO_NONE, protocol);
+ for (size_t repeat = 0; repeat < 2; ++repeat) {
+ for (int set_protocol : {PTHREAD_PRIO_NONE, PTHREAD_PRIO_INHERIT}) {
+ ASSERT_EQ(0, pthread_mutexattr_setprotocol(&attr, set_protocol));
+ ASSERT_EQ(0, pthread_mutexattr_getprotocol(&attr, &protocol));
+ ASSERT_EQ(protocol, set_protocol);
+ }
+ }
+}
+
struct PthreadMutex {
pthread_mutex_t lock;
- explicit PthreadMutex(int mutex_type) {
- init(mutex_type);
+ explicit PthreadMutex(int mutex_type, int protocol = PTHREAD_PRIO_NONE) {
+ init(mutex_type, protocol);
}
~PthreadMutex() {
@@ -1643,10 +1661,11 @@
}
private:
- void init(int mutex_type) {
+ void init(int mutex_type, int protocol) {
pthread_mutexattr_t attr;
ASSERT_EQ(0, pthread_mutexattr_init(&attr));
ASSERT_EQ(0, pthread_mutexattr_settype(&attr, mutex_type));
+ ASSERT_EQ(0, pthread_mutexattr_setprotocol(&attr, protocol));
ASSERT_EQ(0, pthread_mutex_init(&lock, &attr));
ASSERT_EQ(0, pthread_mutexattr_destroy(&attr));
}
@@ -1658,8 +1677,8 @@
DISALLOW_COPY_AND_ASSIGN(PthreadMutex);
};
-TEST(pthread, pthread_mutex_lock_NORMAL) {
- PthreadMutex m(PTHREAD_MUTEX_NORMAL);
+static void TestPthreadMutexLockNormal(int protocol) {
+ PthreadMutex m(PTHREAD_MUTEX_NORMAL, protocol);
ASSERT_EQ(0, pthread_mutex_lock(&m.lock));
ASSERT_EQ(0, pthread_mutex_unlock(&m.lock));
@@ -1668,20 +1687,24 @@
ASSERT_EQ(0, pthread_mutex_unlock(&m.lock));
}
-TEST(pthread, pthread_mutex_lock_ERRORCHECK) {
- PthreadMutex m(PTHREAD_MUTEX_ERRORCHECK);
+static void TestPthreadMutexLockErrorCheck(int protocol) {
+ PthreadMutex m(PTHREAD_MUTEX_ERRORCHECK, protocol);
ASSERT_EQ(0, pthread_mutex_lock(&m.lock));
ASSERT_EQ(EDEADLK, pthread_mutex_lock(&m.lock));
ASSERT_EQ(0, pthread_mutex_unlock(&m.lock));
ASSERT_EQ(0, pthread_mutex_trylock(&m.lock));
- ASSERT_EQ(EBUSY, pthread_mutex_trylock(&m.lock));
+ if (protocol == PTHREAD_PRIO_NONE) {
+ ASSERT_EQ(EBUSY, pthread_mutex_trylock(&m.lock));
+ } else {
+ ASSERT_EQ(EDEADLK, pthread_mutex_trylock(&m.lock));
+ }
ASSERT_EQ(0, pthread_mutex_unlock(&m.lock));
ASSERT_EQ(EPERM, pthread_mutex_unlock(&m.lock));
}
-TEST(pthread, pthread_mutex_lock_RECURSIVE) {
- PthreadMutex m(PTHREAD_MUTEX_RECURSIVE);
+static void TestPthreadMutexLockRecursive(int protocol) {
+ PthreadMutex m(PTHREAD_MUTEX_RECURSIVE, protocol);
ASSERT_EQ(0, pthread_mutex_lock(&m.lock));
ASSERT_EQ(0, pthread_mutex_lock(&m.lock));
@@ -1694,6 +1717,28 @@
ASSERT_EQ(EPERM, pthread_mutex_unlock(&m.lock));
}
+TEST(pthread, pthread_mutex_lock_NORMAL) {
+ TestPthreadMutexLockNormal(PTHREAD_PRIO_NONE);
+}
+
+TEST(pthread, pthread_mutex_lock_ERRORCHECK) {
+ TestPthreadMutexLockErrorCheck(PTHREAD_PRIO_NONE);
+}
+
+TEST(pthread, pthread_mutex_lock_RECURSIVE) {
+ TestPthreadMutexLockRecursive(PTHREAD_PRIO_NONE);
+}
+
+TEST(pthread, pthread_mutex_lock_pi) {
+#if defined(__BIONIC__) && !defined(__LP64__)
+ GTEST_LOG_(INFO) << "PTHREAD_PRIO_INHERIT isn't supported in 32bit programs, skipping test";
+ return;
+#endif
+ TestPthreadMutexLockNormal(PTHREAD_PRIO_INHERIT);
+ TestPthreadMutexLockErrorCheck(PTHREAD_PRIO_INHERIT);
+ TestPthreadMutexLockRecursive(PTHREAD_PRIO_INHERIT);
+}
+
TEST(pthread, pthread_mutex_init_same_as_static_initializers) {
pthread_mutex_t lock_normal = PTHREAD_MUTEX_INITIALIZER;
PthreadMutex m1(PTHREAD_MUTEX_NORMAL);
@@ -1773,6 +1818,103 @@
helper.test();
}
+static int GetThreadPriority(pid_t tid) {
+ // sched_getparam() returns the static priority of a thread, which can't reflect a thread's
+ // priority after priority inheritance. So read /proc/<pid>/stat to get the dynamic priority.
+ std::string filename = android::base::StringPrintf("/proc/%d/stat", tid);
+ std::string content;
+ int result = INT_MAX;
+ if (!android::base::ReadFileToString(filename, &content)) {
+ return result;
+ }
+ std::vector<std::string> strs = android::base::Split(content, " ");
+ if (strs.size() < 18) {
+ return result;
+ }
+ if (!android::base::ParseInt(strs[17], &result)) {
+ return INT_MAX;
+ }
+ return result;
+}
+
+class PIMutexWakeupHelper {
+private:
+ PthreadMutex m;
+ int protocol;
+ enum Progress {
+ LOCK_INITIALIZED,
+ LOCK_CHILD_READY,
+ LOCK_WAITING,
+ LOCK_RELEASED,
+ };
+ std::atomic<Progress> progress;
+ std::atomic<pid_t> main_tid;
+ std::atomic<pid_t> child_tid;
+ PthreadMutex start_thread_m;
+
+ static void thread_fn(PIMutexWakeupHelper* helper) {
+ helper->child_tid = gettid();
+ ASSERT_EQ(LOCK_INITIALIZED, helper->progress);
+ ASSERT_EQ(0, setpriority(PRIO_PROCESS, gettid(), 1));
+ ASSERT_EQ(21, GetThreadPriority(gettid()));
+ ASSERT_EQ(0, pthread_mutex_lock(&helper->m.lock));
+ helper->progress = LOCK_CHILD_READY;
+ ASSERT_EQ(0, pthread_mutex_lock(&helper->start_thread_m.lock));
+
+ ASSERT_EQ(0, pthread_mutex_unlock(&helper->start_thread_m.lock));
+ WaitUntilThreadSleep(helper->main_tid);
+ ASSERT_EQ(LOCK_WAITING, helper->progress);
+
+ if (helper->protocol == PTHREAD_PRIO_INHERIT) {
+ ASSERT_EQ(20, GetThreadPriority(gettid()));
+ } else {
+ ASSERT_EQ(21, GetThreadPriority(gettid()));
+ }
+ helper->progress = LOCK_RELEASED;
+ ASSERT_EQ(0, pthread_mutex_unlock(&helper->m.lock));
+ }
+
+public:
+ explicit PIMutexWakeupHelper(int mutex_type, int protocol)
+ : m(mutex_type, protocol), protocol(protocol), start_thread_m(PTHREAD_MUTEX_NORMAL) {
+ }
+
+ void test() {
+ ASSERT_EQ(0, pthread_mutex_lock(&start_thread_m.lock));
+ main_tid = gettid();
+ ASSERT_EQ(20, GetThreadPriority(main_tid));
+ progress = LOCK_INITIALIZED;
+ child_tid = 0;
+
+ pthread_t thread;
+ ASSERT_EQ(0, pthread_create(&thread, NULL,
+ reinterpret_cast<void* (*)(void*)>(PIMutexWakeupHelper::thread_fn), this));
+
+ WaitUntilThreadSleep(child_tid);
+ ASSERT_EQ(LOCK_CHILD_READY, progress);
+ ASSERT_EQ(0, pthread_mutex_unlock(&start_thread_m.lock));
+ progress = LOCK_WAITING;
+ ASSERT_EQ(0, pthread_mutex_lock(&m.lock));
+
+ ASSERT_EQ(LOCK_RELEASED, progress);
+ ASSERT_EQ(0, pthread_mutex_unlock(&m.lock));
+ ASSERT_EQ(0, pthread_join(thread, nullptr));
+ }
+};
+
+TEST(pthread, pthread_mutex_pi_wakeup) {
+#if defined(__BIONIC__) && !defined(__LP64__)
+ GTEST_LOG_(INFO) << "PTHREAD_PRIO_INHERIT isn't supported in 32bit programs, skipping test";
+ return;
+#endif
+ for (int type : {PTHREAD_MUTEX_NORMAL, PTHREAD_MUTEX_RECURSIVE, PTHREAD_MUTEX_ERRORCHECK}) {
+ for (int protocol : {PTHREAD_PRIO_INHERIT}) {
+ PIMutexWakeupHelper helper(type, protocol);
+ helper.test();
+ }
+ }
+}
+
TEST(pthread, pthread_mutex_owner_tid_limit) {
#if defined(__BIONIC__) && !defined(__LP64__)
FILE* fp = fopen("/proc/sys/kernel/pid_max", "r");
@@ -1816,6 +1958,34 @@
ASSERT_EQ(0, pthread_mutex_destroy(&m));
}
+TEST(pthread, pthread_mutex_timedlock_pi) {
+#if defined(__BIONIC__) && !defined(__LP64__)
+ GTEST_LOG_(INFO) << "PTHREAD_PRIO_INHERIT isn't supported in 32bit programs, skipping test";
+ return;
+#endif
+ PthreadMutex m(PTHREAD_MUTEX_NORMAL, PTHREAD_PRIO_INHERIT);
+ timespec ts;
+ clock_gettime(CLOCK_REALTIME, &ts);
+ ts.tv_sec += 1;
+ ASSERT_EQ(0, pthread_mutex_timedlock(&m.lock, &ts));
+
+ auto ThreadFn = [](void* arg) -> void* {
+ PthreadMutex& m = *static_cast<PthreadMutex*>(arg);
+ timespec ts;
+ clock_gettime(CLOCK_REALTIME, &ts);
+ ts.tv_sec += 1;
+ intptr_t result = pthread_mutex_timedlock(&m.lock, &ts);
+ return reinterpret_cast<void*>(result);
+ };
+
+ pthread_t thread;
+ ASSERT_EQ(0, pthread_create(&thread, NULL, ThreadFn, &m));
+ void* result;
+ ASSERT_EQ(0, pthread_join(thread, &result));
+ ASSERT_EQ(ETIMEDOUT, reinterpret_cast<intptr_t>(result));
+ ASSERT_EQ(0, pthread_mutex_unlock(&m.lock));
+}
+
class StrictAlignmentAllocator {
public:
void* allocate(size_t size, size_t alignment) {