Merge "Do not depend on host bits to get the right size to write."
diff --git a/libc/Android.mk b/libc/Android.mk
index 2849591..99a841a 100644
--- a/libc/Android.mk
+++ b/libc/Android.mk
@@ -584,6 +584,7 @@
bionic/pthread_setname_np.cpp \
bionic/pthread_setschedparam.cpp \
bionic/pthread_sigmask.cpp \
+ bionic/pthread_spinlock.cpp \
libc_thread_atexit_impl_src_files := \
bionic/__cxa_thread_atexit_impl.cpp \
diff --git a/libc/bionic/pthread_mutex.cpp b/libc/bionic/pthread_mutex.cpp
index 851fc3d..3da4bcf 100644
--- a/libc/bionic/pthread_mutex.cpp
+++ b/libc/bionic/pthread_mutex.cpp
@@ -166,11 +166,14 @@
#define MUTEX_STATE_BITS_LOCKED_UNCONTENDED MUTEX_STATE_TO_BITS(MUTEX_STATE_LOCKED_UNCONTENDED)
#define MUTEX_STATE_BITS_LOCKED_CONTENDED MUTEX_STATE_TO_BITS(MUTEX_STATE_LOCKED_CONTENDED)
-/* return true iff the mutex if locked with no waiters */
-#define MUTEX_STATE_BITS_IS_LOCKED_UNCONTENDED(v) (((v) & MUTEX_STATE_MASK) == MUTEX_STATE_BITS_LOCKED_UNCONTENDED)
+// Return true iff the mutex is unlocked.
+#define MUTEX_STATE_BITS_IS_UNLOCKED(v) (((v) & MUTEX_STATE_MASK) == MUTEX_STATE_BITS_UNLOCKED)
-/* return true iff the mutex if locked with maybe waiters */
-#define MUTEX_STATE_BITS_IS_LOCKED_CONTENDED(v) (((v) & MUTEX_STATE_MASK) == MUTEX_STATE_BITS_LOCKED_CONTENDED)
+// Return true iff the mutex is locked with no waiters.
+#define MUTEX_STATE_BITS_IS_LOCKED_UNCONTENDED(v) (((v) & MUTEX_STATE_MASK) == MUTEX_STATE_BITS_LOCKED_UNCONTENDED)
+
+// return true iff the mutex is locked with maybe waiters.
+#define MUTEX_STATE_BITS_IS_LOCKED_CONTENDED(v) (((v) & MUTEX_STATE_MASK) == MUTEX_STATE_BITS_LOCKED_CONTENDED)
/* used to flip from LOCKED_UNCONTENDED to LOCKED_CONTENDED */
#define MUTEX_STATE_BITS_FLIP_CONTENTION(v) ((v) ^ (MUTEX_STATE_BITS_LOCKED_CONTENDED ^ MUTEX_STATE_BITS_LOCKED_UNCONTENDED))
@@ -637,10 +640,14 @@
}
int pthread_mutex_destroy(pthread_mutex_t* mutex_interface) {
- // Use trylock to ensure that the mutex is valid and not already locked.
- int error = pthread_mutex_trylock(mutex_interface);
- if (error != 0) {
- return error;
+ pthread_mutex_internal_t* mutex = __get_internal_mutex(mutex_interface);
+ uint16_t old_state = atomic_load_explicit(&mutex->state, memory_order_relaxed);
+ // 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) &&
+ atomic_compare_exchange_strong_explicit(&mutex->state, &old_state, 0xffff,
+ memory_order_relaxed, memory_order_relaxed)) {
+ return 0;
}
- return 0;
+ return EBUSY;
}
diff --git a/libc/bionic/pthread_spinlock.cpp b/libc/bionic/pthread_spinlock.cpp
new file mode 100644
index 0000000..f26f283
--- /dev/null
+++ b/libc/bionic/pthread_spinlock.cpp
@@ -0,0 +1,81 @@
+/*
+ * Copyright (C) 2015 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 "private/bionic_lock.h"
+
+// User-level spinlocks can be hazardous to battery life on Android.
+// We implement a simple compromise that behaves mostly like a spinlock,
+// but prevents excessively long spinning.
+
+struct pthread_spinlock_internal_t {
+ Lock lock;
+};
+
+static_assert(sizeof(pthread_spinlock_t) == sizeof(pthread_spinlock_internal_t),
+ "pthread_spinlock_t should actually be pthread_spinlock_internal_t.");
+
+static_assert(alignof(pthread_spinlock_t) >= 4,
+ "pthread_spinlock_t should fulfill the alignment of pthread_spinlock_internal_t.");
+
+static inline pthread_spinlock_internal_t* __get_internal_spinlock(pthread_spinlock_t* lock) {
+ return reinterpret_cast<pthread_spinlock_internal_t*>(lock);
+}
+
+int pthread_spin_init(pthread_spinlock_t* lock_interface, int pshared) {
+ pthread_spinlock_internal_t* lock = __get_internal_spinlock(lock_interface);
+ lock->lock.init(pshared);
+ return 0;
+}
+
+int pthread_spin_destroy(pthread_spinlock_t* lock_interface) {
+ pthread_spinlock_internal_t* lock = __get_internal_spinlock(lock_interface);
+ return lock->lock.trylock() ? 0 : EBUSY;
+}
+
+int pthread_spin_trylock(pthread_spinlock_t* lock_interface) {
+ pthread_spinlock_internal_t* lock = __get_internal_spinlock(lock_interface);
+ return lock->lock.trylock() ? 0 : EBUSY;
+}
+
+int pthread_spin_lock(pthread_spinlock_t* lock_interface) {
+ pthread_spinlock_internal_t* lock = __get_internal_spinlock(lock_interface);
+ for (int i = 0; i < 10000; ++i) {
+ if (lock->lock.trylock()) {
+ return 0;
+ }
+ }
+ lock->lock.lock();
+ return 0;
+}
+
+int pthread_spin_unlock(pthread_spinlock_t* lock_interface) {
+ pthread_spinlock_internal_t* lock = __get_internal_spinlock(lock_interface);
+ lock->lock.unlock();
+ return 0;
+}
diff --git a/libc/include/pthread.h b/libc/include/pthread.h
index 48b2bca..21d34fb 100644
--- a/libc/include/pthread.h
+++ b/libc/include/pthread.h
@@ -108,6 +108,14 @@
#define PTHREAD_BARRIER_SERIAL_THREAD -1
+typedef struct {
+#if defined(__LP64__)
+ int64_t __private;
+#else
+ int32_t __private[2];
+#endif
+} pthread_spinlock_t;
+
#if defined(__LP64__)
#define PTHREAD_STACK_MIN (4 * PAGE_SIZE)
#else
@@ -229,6 +237,12 @@
int pthread_barrier_destroy(pthread_barrier_t*) __nonnull((1));
int pthread_barrier_wait(pthread_barrier_t*) __nonnull((1));
+int pthread_spin_destroy(pthread_spinlock_t*) __nonnull((1));
+int pthread_spin_init(pthread_spinlock_t*, int) __nonnull((1));
+int pthread_spin_lock(pthread_spinlock_t*) __nonnull((1));
+int pthread_spin_trylock(pthread_spinlock_t*) __nonnull((1));
+int pthread_spin_unlock(pthread_spinlock_t*) __nonnull((1));
+
pthread_t pthread_self(void) __pure2;
int pthread_setname_np(pthread_t, const char*) __nonnull((2));
diff --git a/libc/libc.arm.map b/libc/libc.arm.map
index f7805fe..69aa272 100644
--- a/libc/libc.arm.map
+++ b/libc/libc.arm.map
@@ -1323,6 +1323,11 @@
pthread_barrier_destroy;
pthread_barrier_init;
pthread_barrier_wait;
+ pthread_spin_destroy;
+ pthread_spin_init;
+ pthread_spin_lock;
+ pthread_spin_trylock;
+ pthread_spin_unlock;
pwritev;
pwritev64;
scandirat;
diff --git a/libc/libc.arm64.map b/libc/libc.arm64.map
index d5fe262..763f77e 100644
--- a/libc/libc.arm64.map
+++ b/libc/libc.arm64.map
@@ -1168,6 +1168,11 @@
pthread_barrier_destroy;
pthread_barrier_init;
pthread_barrier_wait;
+ pthread_spin_destroy;
+ pthread_spin_init;
+ pthread_spin_lock;
+ pthread_spin_trylock;
+ pthread_spin_unlock;
pwritev;
pwritev64;
scandirat;
diff --git a/libc/libc.map.txt b/libc/libc.map.txt
index 738836c..76cb168 100644
--- a/libc/libc.map.txt
+++ b/libc/libc.map.txt
@@ -1350,6 +1350,11 @@
pthread_barrier_destroy;
pthread_barrier_init;
pthread_barrier_wait;
+ pthread_spin_destroy;
+ pthread_spin_init;
+ pthread_spin_lock;
+ pthread_spin_trylock;
+ pthread_spin_unlock;
pwritev;
pwritev64;
scandirat;
diff --git a/libc/libc.mips.map b/libc/libc.mips.map
index 2121ba7..e268bad 100644
--- a/libc/libc.mips.map
+++ b/libc/libc.mips.map
@@ -1286,6 +1286,11 @@
pthread_barrier_destroy;
pthread_barrier_init;
pthread_barrier_wait;
+ pthread_spin_destroy;
+ pthread_spin_init;
+ pthread_spin_lock;
+ pthread_spin_trylock;
+ pthread_spin_unlock;
pwritev;
pwritev64;
scandirat;
diff --git a/libc/libc.mips64.map b/libc/libc.mips64.map
index d5fe262..763f77e 100644
--- a/libc/libc.mips64.map
+++ b/libc/libc.mips64.map
@@ -1168,6 +1168,11 @@
pthread_barrier_destroy;
pthread_barrier_init;
pthread_barrier_wait;
+ pthread_spin_destroy;
+ pthread_spin_init;
+ pthread_spin_lock;
+ pthread_spin_trylock;
+ pthread_spin_unlock;
pwritev;
pwritev64;
scandirat;
diff --git a/libc/libc.x86.map b/libc/libc.x86.map
index fdee2c6..6578370 100644
--- a/libc/libc.x86.map
+++ b/libc/libc.x86.map
@@ -1284,6 +1284,11 @@
pthread_barrier_destroy;
pthread_barrier_init;
pthread_barrier_wait;
+ pthread_spin_destroy;
+ pthread_spin_init;
+ pthread_spin_lock;
+ pthread_spin_trylock;
+ pthread_spin_unlock;
pwritev;
pwritev64;
scandirat;
diff --git a/libc/libc.x86_64.map b/libc/libc.x86_64.map
index d5fe262..763f77e 100644
--- a/libc/libc.x86_64.map
+++ b/libc/libc.x86_64.map
@@ -1168,6 +1168,11 @@
pthread_barrier_destroy;
pthread_barrier_init;
pthread_barrier_wait;
+ pthread_spin_destroy;
+ pthread_spin_init;
+ pthread_spin_lock;
+ pthread_spin_trylock;
+ pthread_spin_unlock;
pwritev;
pwritev64;
scandirat;
diff --git a/libc/private/bionic_lock.h b/libc/private/bionic_lock.h
index a36d1ed..238ace4 100644
--- a/libc/private/bionic_lock.h
+++ b/libc/private/bionic_lock.h
@@ -30,6 +30,7 @@
#include <stdatomic.h>
#include "private/bionic_futex.h"
+#include "private/bionic_macros.h"
// Lock is used in places like pthread_rwlock_t, which can be initialized without calling
// an initialization function. So make sure Lock can be initialized by setting its memory to 0.
@@ -49,6 +50,12 @@
this->process_shared = process_shared;
}
+ bool trylock() {
+ LockState old_state = Unlocked;
+ return __predict_true(atomic_compare_exchange_strong_explicit(&state, &old_state,
+ LockedWithoutWaiter, memory_order_acquire, memory_order_relaxed));
+ }
+
void lock() {
LockState old_state = Unlocked;
if (__predict_true(atomic_compare_exchange_strong_explicit(&state, &old_state,
diff --git a/linker/linker.cpp b/linker/linker.cpp
index a67b430..9cc4aba 100644
--- a/linker/linker.cpp
+++ b/linker/linker.cpp
@@ -2255,9 +2255,12 @@
g_public_namespace.clear();
});
- soinfo* candidate;
for (const auto& soname : sonames) {
- if (!find_loaded_library_by_soname(&g_default_namespace, soname.c_str(), &candidate)) {
+ soinfo* candidate = nullptr;
+
+ find_loaded_library_by_soname(&g_default_namespace, soname.c_str(), &candidate);
+
+ if (candidate == nullptr) {
DL_ERR("Error initializing public namespace: \"%s\" was not found"
" in the default namespace", soname.c_str());
return false;
diff --git a/tests/dlext_test.cpp b/tests/dlext_test.cpp
index 83bd5cc..a56c771 100644
--- a/tests/dlext_test.cpp
+++ b/tests/dlext_test.cpp
@@ -707,6 +707,8 @@
dlclose(handle2);
}
+extern "C" void android_set_application_target_sdk_version(uint32_t target);
+
TEST(dlext, ns_isolated) {
static const char* root_lib = "libnstest_root_not_isolated.so";
std::string path = std::string("libc.so:libc++.so:libdl.so:libm.so:") + g_public_lib;
@@ -715,6 +717,8 @@
void* handle_public = dlopen((lib_path + "/public_namespace_libs/" + g_public_lib).c_str(), RTLD_NOW);
ASSERT_TRUE(handle_public != nullptr) << dlerror();
+ android_set_application_target_sdk_version(42U); // something > 23
+
ASSERT_TRUE(android_init_public_namespace(path.c_str())) << dlerror();
android_namespace_t* ns_not_isolated = android_create_namespace("private", nullptr, (lib_path + "/private_namespace_libs").c_str(), false);
diff --git a/tests/pthread_test.cpp b/tests/pthread_test.cpp
index e62518a..e237d26 100755
--- a/tests/pthread_test.cpp
+++ b/tests/pthread_test.cpp
@@ -1779,3 +1779,14 @@
ASSERT_EQ(0, pthread_join(threads[i], nullptr));
}
}
+
+TEST(pthread, pthread_spinlock_smoke) {
+ pthread_spinlock_t lock;
+ ASSERT_EQ(0, pthread_spin_init(&lock, 0));
+ ASSERT_EQ(0, pthread_spin_trylock(&lock));
+ ASSERT_EQ(0, pthread_spin_unlock(&lock));
+ ASSERT_EQ(0, pthread_spin_lock(&lock));
+ ASSERT_EQ(EBUSY, pthread_spin_trylock(&lock));
+ ASSERT_EQ(0, pthread_spin_unlock(&lock));
+ ASSERT_EQ(0, pthread_spin_destroy(&lock));
+}