index 2ded22b0f339e04a04a0558ed84cda8c1b09d993..c47b750484537b6a45c370747aa705ff2567e158 100644 (file)
#include "pthread_internal.h"
#include "private/bionic_macros.h"
+#include "private/bionic_prctl.h"
#include "private/bionic_ssp.h"
#include "private/bionic_tls.h"
#include "private/libc_logging.h"
#include "private/ErrnoRestorer.h"
#include "private/ScopedPthreadMutexLocker.h"
-// Used by gdb to track thread creation. See libthread_db.
-#ifdef __i386__
-extern "C" __attribute__((noinline)) __attribute__((fastcall)) void _thread_created_hook(pid_t) {}
-#else
-extern "C" __attribute__((noinline)) void _thread_created_hook(pid_t) {}
-#endif
-
// x86 uses segment descriptors rather than a direct pointer to TLS.
#if __i386__
#include <asm/ldt.h>
extern "C" __LIBC_HIDDEN__ void __init_user_desc(struct user_desc*, int, void*);
#endif
-static pthread_mutex_t g_pthread_stack_creation_lock = PTHREAD_MUTEX_INITIALIZER;
-
-static pthread_mutex_t g_debugger_notification_lock = PTHREAD_MUTEX_INITIALIZER;
-
extern "C" int __isthreaded;
// This code is used both by each new pthread and the code that initializes the main thread.
void __init_tls(pthread_internal_t* thread) {
- // Zero-initialize all the slots after TLS_SLOT_SELF and TLS_SLOT_THREAD_ID.
- for (size_t i = TLS_SLOT_ERRNO; i < BIONIC_TLS_SLOTS; ++i) {
- thread->tls[i] = NULL;
+ if (thread->user_allocated_stack()) {
+ // We don't know where the user got their stack, so assume the worst and zero the TLS area.
+ memset(&thread->tls[0], 0, BIONIC_TLS_SLOTS * sizeof(void*));
}
// Slot 0 must point to itself. The x86 Linux kernel reads the TLS from %fs:0.
void __init_alternate_signal_stack(pthread_internal_t* thread) {
// Create and set an alternate signal stack.
stack_t ss;
- ss.ss_sp = mmap(NULL, SIGSTKSZ, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, 0, 0);
+ ss.ss_sp = mmap(NULL, SIGSTKSZ, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
if (ss.ss_sp != MAP_FAILED) {
ss.ss_size = SIGSTKSZ;
ss.ss_flags = 0;
sigaltstack(&ss, NULL);
thread->alternate_signal_stack = ss.ss_sp;
+
+ // We can only use const static allocated string for mapped region name, as Android kernel
+ // uses the string pointer directly when dumping /proc/pid/maps.
+ prctl(PR_SET_VMA, PR_SET_VMA_ANON_NAME, ss.ss_sp, ss.ss_size, "thread signal stack");
}
}
return error;
}
-static void* __create_thread_stack(pthread_internal_t* thread) {
- ScopedPthreadMutexLocker lock(&g_pthread_stack_creation_lock);
-
+static void* __create_thread_stack(const pthread_attr_t& attr) {
// Create a new private anonymous map.
int prot = PROT_READ | PROT_WRITE;
int flags = MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE;
- void* stack = mmap(NULL, thread->attr.stack_size, prot, flags, -1, 0);
+ void* stack = mmap(NULL, attr.stack_size, prot, flags, -1, 0);
if (stack == MAP_FAILED) {
__libc_format_log(ANDROID_LOG_WARN,
"libc",
"pthread_create failed: couldn't allocate %zd-byte stack: %s",
- thread->attr.stack_size, strerror(errno));
+ attr.stack_size, strerror(errno));
return NULL;
}
// Set the guard region at the end of the stack to PROT_NONE.
- if (mprotect(stack, thread->attr.guard_size, PROT_NONE) == -1) {
+ if (mprotect(stack, attr.guard_size, PROT_NONE) == -1) {
__libc_format_log(ANDROID_LOG_WARN, "libc",
"pthread_create failed: couldn't mprotect PROT_NONE %zd-byte stack guard region: %s",
- thread->attr.guard_size, strerror(errno));
- munmap(stack, thread->attr.stack_size);
+ attr.guard_size, strerror(errno));
+ munmap(stack, attr.stack_size);
return NULL;
}
return stack;
}
+static int __allocate_thread(pthread_attr_t* attr, pthread_internal_t** threadp, void** child_stack) {
+ if (attr->stack_base == NULL) {
+ // The caller didn't provide a stack, so allocate one.
+ // Make sure the stack size and guard size are multiples of PAGE_SIZE.
+ attr->stack_size = BIONIC_ALIGN(attr->stack_size, PAGE_SIZE);
+ attr->guard_size = BIONIC_ALIGN(attr->guard_size, PAGE_SIZE);
+ attr->stack_base = __create_thread_stack(*attr);
+ if (attr->stack_base == NULL) {
+ return EAGAIN;
+ }
+ } else {
+ // The caller did provide a stack, so remember we're not supposed to free it.
+ attr->flags |= PTHREAD_ATTR_FLAG_USER_ALLOCATED_STACK;
+ }
+
+ // Thread stack is used for two sections:
+ // pthread_internal_t.
+ // regular stack, from top to down.
+ uint8_t* stack_top = reinterpret_cast<uint8_t*>(attr->stack_base) + attr->stack_size;
+ stack_top -= sizeof(pthread_internal_t);
+ pthread_internal_t* thread = reinterpret_cast<pthread_internal_t*>(stack_top);
+
+ // No need to check stack_top alignment. The size of pthread_internal_t is 16-bytes aligned,
+ // and user allocated stack is guaranteed by pthread_attr_setstack.
+
+ thread->attr = *attr;
+ __init_tls(thread);
+
+ *threadp = thread;
+ *child_stack = stack_top;
+ return 0;
+}
+
static int __pthread_start(void* arg) {
pthread_internal_t* thread = reinterpret_cast<pthread_internal_t*>(arg);
// Inform the rest of the C library that at least one thread was created.
__isthreaded = 1;
- pthread_internal_t* thread = reinterpret_cast<pthread_internal_t*>(calloc(sizeof(*thread), 1));
- if (thread == NULL) {
- __libc_format_log(ANDROID_LOG_WARN, "libc", "pthread_create failed: couldn't allocate thread");
- return EAGAIN;
- }
-
+ pthread_attr_t thread_attr;
if (attr == NULL) {
- pthread_attr_init(&thread->attr);
+ pthread_attr_init(&thread_attr);
} else {
- thread->attr = *attr;
+ thread_attr = *attr;
attr = NULL; // Prevent misuse below.
}
- // Make sure the stack size and guard size are multiples of PAGE_SIZE.
- thread->attr.stack_size = BIONIC_ALIGN(thread->attr.stack_size, PAGE_SIZE);
- thread->attr.guard_size = BIONIC_ALIGN(thread->attr.guard_size, PAGE_SIZE);
-
- if (thread->attr.stack_base == NULL) {
- // The caller didn't provide a stack, so allocate one.
- thread->attr.stack_base = __create_thread_stack(thread);
- if (thread->attr.stack_base == NULL) {
- free(thread);
- return EAGAIN;
- }
- } else {
- // The caller did provide a stack, so remember we're not supposed to free it.
- thread->attr.flags |= PTHREAD_ATTR_FLAG_USER_ALLOCATED_STACK;
+ pthread_internal_t* thread = NULL;
+ void* child_stack = NULL;
+ int result = __allocate_thread(&thread_attr, &thread, &child_stack);
+ if (result != 0) {
+ return result;
}
- // Make room for the TLS area.
- // The child stack is the same address, just growing in the opposite direction.
- // At offsets >= 0, we have the TLS slots.
- // At offsets < 0, we have the child stack.
- thread->tls = reinterpret_cast<void**>(reinterpret_cast<uint8_t*>(thread->attr.stack_base) +
- thread->attr.stack_size - BIONIC_TLS_SLOTS * sizeof(void*));
- void* child_stack = thread->tls;
- __init_tls(thread);
-
// Create a mutex for the thread in TLS to wait on once it starts so we can keep
// it from doing anything until after we notify the debugger about it
//
int flags = CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | CLONE_THREAD | CLONE_SYSVSEM |
CLONE_SETTLS | CLONE_PARENT_SETTID | CLONE_CHILD_CLEARTID;
- void* tls = thread->tls;
+ void* tls = reinterpret_cast<void*>(thread->tls);
#if defined(__i386__)
// On x86 (but not x86-64), CLONE_SETTLS takes a pointer to a struct user_desc rather than
// a pointer to the TLS itself.
// be unblocked, but we're about to unmap the memory the mutex is stored in, so this serves as a
// reminder that you can't rewrite this function to use a ScopedPthreadMutexLocker.
pthread_mutex_unlock(&thread->startup_handshake_mutex);
- if ((thread->attr.flags & PTHREAD_ATTR_FLAG_USER_ALLOCATED_STACK) == 0) {
+ if (!thread->user_allocated_stack()) {
munmap(thread->attr.stack_base, thread->attr.stack_size);
}
- free(thread);
__libc_format_log(ANDROID_LOG_WARN, "libc", "pthread_create failed: clone failed: %s", strerror(errno));
return clone_errno;
}
return init_errno;
}
- // Notify any debuggers about the new thread.
- {
- ScopedPthreadMutexLocker debugger_locker(&g_debugger_notification_lock);
- _thread_created_hook(thread->tid);
- }
-
// Publish the pthread_t and unlock the mutex to let the new thread start running.
*thread_out = reinterpret_cast<pthread_t>(thread);
pthread_mutex_unlock(&thread->startup_handshake_mutex);