generic-library/bionic
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Remove PTHREAD_ATTR_FLAG_USER_ALLOCATED_STACK.

Browse Source 
Patch for https://android-review.googlesource.com/#/c/120844/.

Change-Id: Idca5ccd7b28e8f07f1d2d1b6e3bba6781b62f0e0
This commit is contained in:
Yabin Cui
2015-01-06 09:31:00 -08:00
parent 597800f1d7
commit ba8dfc2669
5 changed files with 44 additions and 56 deletions
Download Patch File Download Diff File Expand all files Collapse all files

53
libc/bionic/pthread_create.cpp
View File

@@ -52,8 +52,9 @@ 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) {
if (thread->user_allocated_stack()) {
// We don't know where the user got their stack, so assume the worst and zero the TLS area.
if (thread->mmap_size == 0) {
// If the TLS area was not allocated by mmap(), it may not have been cleared to zero.
// So assume the worst and zero the TLS area.
memset(&thread->tls[0], 0, BIONIC_TLS_SLOTS * sizeof(void*));
}
@@ -106,62 +107,62 @@ int __init_thread(pthread_internal_t* thread, bool add_to_thread_list) {
return error;
}
static void* __create_thread_stack(size_t stack_size, size_t guard_size) {
static void* __create_thread_mapped_space(size_t mmap_size, size_t stack_guard_size) {
// Create a new private anonymous map.
int prot = PROT_READ | PROT_WRITE;
int flags = MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE;
void* stack = mmap(NULL, stack_size, prot, flags, -1, 0);
if (stack == MAP_FAILED) {
void* space = mmap(NULL, mmap_size, prot, flags, -1, 0);
if (space == MAP_FAILED) {
__libc_format_log(ANDROID_LOG_WARN,
"libc",
"pthread_create failed: couldn't allocate %zd-byte stack: %s",
stack_size, strerror(errno));
"pthread_create failed: couldn't allocate %zu-bytes mapped space: %s",
mmap_size, strerror(errno));
return NULL;
}
// Set the guard region at the end of the stack to PROT_NONE.
if (mprotect(stack, guard_size, PROT_NONE) == -1) {
// Stack is at the lower end of mapped space, stack guard region is at the lower end of stack.
// Set the stack guard region to PROT_NONE, so we can detect thread stack overflow.
if (mprotect(space, stack_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",
guard_size, strerror(errno));
munmap(stack, stack_size);
"pthread_create failed: couldn't mprotect PROT_NONE %zu-byte stack guard region: %s",
stack_guard_size, strerror(errno));
munmap(space, mmap_size);
return NULL;
}
return stack;
return space;
}
static int __allocate_thread(pthread_attr_t* attr, pthread_internal_t** threadp, void** child_stack) {
size_t allocate_stack_size;
size_t mmap_size;
uint8_t* stack_top;
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.
allocate_stack_size = BIONIC_ALIGN(attr->stack_size + sizeof(pthread_internal_t), PAGE_SIZE);
mmap_size = BIONIC_ALIGN(attr->stack_size + sizeof(pthread_internal_t), PAGE_SIZE);
attr->guard_size = BIONIC_ALIGN(attr->guard_size, PAGE_SIZE);
attr->stack_base = __create_thread_stack(allocate_stack_size, attr->guard_size);
attr->stack_base = __create_thread_mapped_space(mmap_size, attr->guard_size);
if (attr->stack_base == NULL) {
return EAGAIN;
}
stack_top = reinterpret_cast<uint8_t*>(attr->stack_base) + allocate_stack_size;
stack_top = reinterpret_cast<uint8_t*>(attr->stack_base) + mmap_size;
} else {
// The caller did provide a stack, so remember we're not supposed to free it.
attr->flags |= PTHREAD_ATTR_FLAG_USER_ALLOCATED_STACK;
allocate_stack_size = 0;
// Remember the mmap size is zero and we don't need to free it.
mmap_size = 0;
stack_top = reinterpret_cast<uint8_t*>(attr->stack_base) + attr->stack_size;
}
// Thread stack is used for two sections:
// pthread_internal_t.
// regular stack, from top to down.
// Mapped space(or user allocated stack) is used for:
// thread_internal_t (including tls array)
// thread stack (including guard page)
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->allocated_stack_size = allocate_stack_size;
thread->mmap_size = mmap_size;
thread->attr = *attr;
__init_tls(thread);
@@ -248,8 +249,8 @@ int pthread_create(pthread_t* thread_out, pthread_attr_t const* attr,
// 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->user_allocated_stack()) {
munmap(thread->attr.stack_base, thread->allocated_stack_size);
if (thread->mmap_size != 0) {
munmap(thread->attr.stack_base, thread->mmap_size);
}
__libc_format_log(ANDROID_LOG_WARN, "libc", "pthread_create failed: clone failed: %s", strerror(errno));
return clone_errno;