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

resolved conflicts for merge of 6cf3c7c5 to jb-dev-plus-aosp

Browse Source 
Change-Id: Ib22a8ae1ef63bf9b9c82ce6e22afd188ba7c2806
This commit is contained in:
Elliott Hughes 2012-05-08 13:26:28 -07:00
commit 9c3eca7bce
2 changed files with 90 additions and 106 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

192
libc/bionic/pthread.c
View File

@ -25,31 +25,32 @@
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE. * SUCH DAMAGE.
*/ */
#include <sys/types.h>
#include <unistd.h> #include <assert.h>
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <malloc.h>
#include <memory.h>
#include <pthread.h>
#include <signal.h> #include <signal.h>
#include <stdint.h> #include <stdint.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <errno.h>
#include <sys/atomics.h> #include <sys/atomics.h>
#include <bionic_tls.h>
#include <sys/mman.h> #include <sys/mman.h>
#include <pthread.h>
#include <time.h>
#include "pthread_internal.h"
#include "thread_private.h"
#include <limits.h>
#include <memory.h>
#include <assert.h>
#include <malloc.h>
#include <bionic_futex.h>
#include <bionic_atomic_inline.h>
#include <sys/prctl.h> #include <sys/prctl.h>
#include <sys/stat.h> #include <sys/stat.h>
#include <fcntl.h> #include <sys/types.h>
#include <stdio.h> #include <time.h>
#include <bionic_pthread.h> #include <unistd.h>
#include "bionic_atomic_inline.h"
#include "bionic_futex.h"
#include "bionic_pthread.h"
#include "bionic_tls.h"
#include "pthread_internal.h"
#include "thread_private.h"
extern void pthread_debug_mutex_lock_check(pthread_mutex_t *mutex); extern void pthread_debug_mutex_lock_check(pthread_mutex_t *mutex);
extern void pthread_debug_mutex_unlock_check(pthread_mutex_t *mutex); extern void pthread_debug_mutex_unlock_check(pthread_mutex_t *mutex);
@ -80,6 +81,8 @@ int __futex_wait_ex(volatile void *ftx, int pshared, int val, const struct time
void ATTRIBUTES _thread_created_hook(pid_t thread_id); void ATTRIBUTES _thread_created_hook(pid_t thread_id);
static const int kPthreadInitFailed = 1;
#define PTHREAD_ATTR_FLAG_DETACHED 0x00000001 #define PTHREAD_ATTR_FLAG_DETACHED 0x00000001
#define PTHREAD_ATTR_FLAG_USER_STACK 0x00000002 #define PTHREAD_ATTR_FLAG_USER_STACK 0x00000002
@ -97,35 +100,16 @@ static const pthread_attr_t gDefaultPthreadAttr = {
.sched_priority = 0 .sched_priority = 0
}; };
#define INIT_THREADS 1 static pthread_internal_t* gThreadList = NULL;
static pthread_internal_t* gThreadList = NULL;
static pthread_mutex_t gThreadListLock = PTHREAD_MUTEX_INITIALIZER; static pthread_mutex_t gThreadListLock = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t gDebuggerNotificationLock = PTHREAD_MUTEX_INITIALIZER; static pthread_mutex_t gDebuggerNotificationLock = PTHREAD_MUTEX_INITIALIZER;
/* we simply malloc/free the internal pthread_internal_t structures. we may
* want to use a different allocation scheme in the future, but this one should
* be largely enough
*/
static pthread_internal_t*
_pthread_internal_alloc(void)
{
pthread_internal_t* thread;
thread = calloc( sizeof(*thread), 1 );
if (thread)
thread->intern = 1;
return thread;
}
static void static void
_pthread_internal_free( pthread_internal_t* thread ) _pthread_internal_free(pthread_internal_t* thread)
{ {
if (thread && thread->intern) { if (thread != NULL) {
thread->intern = 0; /* just in case */ free(thread);
free (thread);
} }
} }
@ -194,32 +178,35 @@ void __init_tls(void** tls, void* thread)
/* /*
* This trampoline is called from the assembly clone() function * This trampoline is called from the assembly _pthread_clone() function.
*/ */
void __thread_entry(int (*func)(void*), void *arg, void **tls) void __thread_entry(int (*func)(void*), void *arg, void **tls)
{ {
int retValue;
pthread_internal_t * thrInfo;
// Wait for our creating thread to release us. This lets it have time to // Wait for our creating thread to release us. This lets it have time to
// notify gdb about this thread before it starts doing anything. // notify gdb about this thread before we start doing anything.
// //
// This also provides the memory barrier needed to ensure that all memory // This also provides the memory barrier needed to ensure that all memory
// accesses previously made by the creating thread are visible to us. // accesses previously made by the creating thread are visible to us.
pthread_mutex_t * start_mutex = (pthread_mutex_t *)&tls[TLS_SLOT_SELF]; pthread_mutex_t* start_mutex = (pthread_mutex_t*) &tls[TLS_SLOT_SELF];
pthread_mutex_lock(start_mutex); pthread_mutex_lock(start_mutex);
pthread_mutex_destroy(start_mutex); pthread_mutex_destroy(start_mutex);
thrInfo = (pthread_internal_t *) tls[TLS_SLOT_THREAD_ID]; pthread_internal_t* thread = (pthread_internal_t*) tls[TLS_SLOT_THREAD_ID];
__init_tls(tls, thread);
__init_tls( tls, thrInfo ); if ((thread->internal_flags & kPthreadInitFailed) != 0) {
pthread_exit(NULL);
}
pthread_exit( (void*)func(arg) ); int result = func(arg);
pthread_exit((void*) result);
} }
__LIBC_ABI_PRIVATE__ __LIBC_ABI_PRIVATE__
void _init_thread(pthread_internal_t * thread, pid_t kernel_id, pthread_attr_t * attr, void * stack_base) int _init_thread(pthread_internal_t * thread, pid_t kernel_id, pthread_attr_t * attr, void * stack_base)
{ {
int error = 0;
if (attr == NULL) { if (attr == NULL) {
thread->attr = gDefaultPthreadAttr; thread->attr = gDefaultPthreadAttr;
} else { } else {
@ -228,40 +215,42 @@ void _init_thread(pthread_internal_t * thread, pid_t kernel_id, pthread_attr_t *
thread->attr.stack_base = stack_base; thread->attr.stack_base = stack_base;
thread->kernel_id = kernel_id; thread->kernel_id = kernel_id;
// set the scheduling policy/priority of the thread // Make a note of whether the user supplied this stack (so we know whether or not to free it).
if (attr->stack_base == stack_base) {
thread->attr.flags |= PTHREAD_ATTR_FLAG_USER_STACK;
}
// Set the scheduling policy/priority of the thread.
if (thread->attr.sched_policy != SCHED_NORMAL) { if (thread->attr.sched_policy != SCHED_NORMAL) {
struct sched_param param; struct sched_param param;
param.sched_priority = thread->attr.sched_priority; param.sched_priority = thread->attr.sched_priority;
sched_setscheduler(kernel_id, thread->attr.sched_policy, &param); if (sched_setscheduler(kernel_id, thread->attr.sched_policy, &param) == -1) {
error = errno;
}
} }
pthread_cond_init(&thread->join_cond, NULL); pthread_cond_init(&thread->join_cond, NULL);
thread->join_count = 0; thread->join_count = 0;
thread->cleanup_stack = NULL; thread->cleanup_stack = NULL;
_pthread_internal_add(thread);
return error;
} }
/* XXX stacks not reclaimed if thread spawn fails */
/* XXX stacks address spaces should be reused if available again */
static void *mkstack(size_t size, size_t guard_size) static void *mkstack(size_t size, size_t guard_size)
{ {
void * stack;
pthread_mutex_lock(&mmap_lock); pthread_mutex_lock(&mmap_lock);
stack = mmap(NULL, size, int prot = PROT_READ | PROT_WRITE;
PROT_READ | PROT_WRITE, int flags = MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE;
MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE, void* stack = mmap(NULL, size, prot, flags, -1, 0);
-1, 0); if (stack == MAP_FAILED) {
if(stack == MAP_FAILED) {
stack = NULL; stack = NULL;
goto done; goto done;
} }
if(mprotect(stack, guard_size, PROT_NONE)){ if (mprotect(stack, guard_size, PROT_NONE) == -1) {
munmap(stack, size); munmap(stack, size);
stack = NULL; stack = NULL;
goto done; goto done;
@ -298,13 +287,7 @@ done:
int pthread_create(pthread_t *thread_out, pthread_attr_t const * attr, int pthread_create(pthread_t *thread_out, pthread_attr_t const * attr,
void *(*start_routine)(void *), void * arg) void *(*start_routine)(void *), void * arg)
{ {
char* stack; int old_errno = errno;
void** tls;
int tid;
pthread_mutex_t * start_mutex;
pthread_internal_t * thread;
int madestack = 0;
int old_errno = errno;
/* this will inform the rest of the C library that at least one thread /* this will inform the rest of the C library that at least one thread
* was created. this will enforce certain functions to acquire/release * was created. this will enforce certain functions to acquire/release
@ -315,31 +298,28 @@ int pthread_create(pthread_t *thread_out, pthread_attr_t const * attr,
*/ */
__isthreaded = 1; __isthreaded = 1;
thread = _pthread_internal_alloc(); pthread_internal_t* thread = calloc(sizeof(*thread), 1);
if (thread == NULL) if (thread == NULL) {
return ENOMEM; return ENOMEM;
}
if (attr == NULL) { if (attr == NULL) {
attr = &gDefaultPthreadAttr; attr = &gDefaultPthreadAttr;
} }
// make sure the stack is PAGE_SIZE aligned // make sure the stack is PAGE_SIZE aligned
size_t stackSize = (attr->stack_size + size_t stack_size = (attr->stack_size + (PAGE_SIZE-1)) & ~(PAGE_SIZE-1);
(PAGE_SIZE-1)) & ~(PAGE_SIZE-1); uint8_t* stack = attr->stack_base;
if (stack == NULL) {
if (!attr->stack_base) { stack = mkstack(stack_size, attr->guard_size);
stack = mkstack(stackSize, attr->guard_size); if (stack == NULL) {
if(stack == NULL) {
_pthread_internal_free(thread); _pthread_internal_free(thread);
return ENOMEM; return ENOMEM;
} }
madestack = 1;
} else {
stack = attr->stack_base;
} }
// Make room for TLS // Make room for TLS
tls = (void**)(stack + stackSize - BIONIC_TLS_SLOTS*sizeof(void*)); void** tls = (void**)(stack + stack_size - BIONIC_TLS_SLOTS*sizeof(void*));
// Create a mutex for the thread in TLS_SLOT_SELF to wait on once it starts so we can keep // Create a mutex for the thread in TLS_SLOT_SELF to wait on once it starts so we can keep
// it from doing anything until after we notify the debugger about it // it from doing anything until after we notify the debugger about it
@ -347,43 +327,47 @@ int pthread_create(pthread_t *thread_out, pthread_attr_t const * attr,
// This also provides the memory barrier we need to ensure that all // This also provides the memory barrier we need to ensure that all
// memory accesses previously performed by this thread are visible to // memory accesses previously performed by this thread are visible to
// the new thread. // the new thread.
start_mutex = (pthread_mutex_t *) &tls[TLS_SLOT_SELF]; pthread_mutex_t* start_mutex = (pthread_mutex_t*) &tls[TLS_SLOT_SELF];
pthread_mutex_init(start_mutex, NULL); pthread_mutex_init(start_mutex, NULL);
pthread_mutex_lock(start_mutex); pthread_mutex_lock(start_mutex);
tls[TLS_SLOT_THREAD_ID] = thread; tls[TLS_SLOT_THREAD_ID] = thread;
tid = __pthread_clone((int(*)(void*))start_routine, tls, int flags = CLONE_FILES | CLONE_FS | CLONE_VM | CLONE_SIGHAND |
CLONE_FILES | CLONE_FS | CLONE_VM | CLONE_SIGHAND CLONE_THREAD | CLONE_SYSVSEM | CLONE_DETACHED;
| CLONE_THREAD | CLONE_SYSVSEM | CLONE_DETACHED, int tid = __pthread_clone((int(*)(void*))start_routine, tls, flags, arg);
arg);
if(tid < 0) { if (tid < 0) {
int result; int clone_errno = errno;
if (madestack) pthread_mutex_unlock(start_mutex);
munmap(stack, stackSize); if (stack != attr->stack_base) {
munmap(stack, stack_size);
}
_pthread_internal_free(thread); _pthread_internal_free(thread);
result = errno;
errno = old_errno; errno = old_errno;
return result; return clone_errno;
} }
_init_thread(thread, tid, (pthread_attr_t*)attr, stack); int init_errno = _init_thread(thread, tid, (pthread_attr_t*) attr, stack);
if (init_errno != 0) {
// Mark the thread detached and let its __thread_entry run to
// completion. (It'll just exit immediately, cleaning up its resources.)
thread->internal_flags |= kPthreadInitFailed;
thread->attr.flags |= PTHREAD_ATTR_FLAG_DETACHED;
pthread_mutex_unlock(start_mutex);
errno = old_errno;
return init_errno;
}
_pthread_internal_add(thread); // Notify any debuggers about the new thread.
if (!madestack)
thread->attr.flags |= PTHREAD_ATTR_FLAG_USER_STACK;
// Notify any debuggers about the new thread
pthread_mutex_lock(&gDebuggerNotificationLock); pthread_mutex_lock(&gDebuggerNotificationLock);
_thread_created_hook(tid); _thread_created_hook(tid);
pthread_mutex_unlock(&gDebuggerNotificationLock); pthread_mutex_unlock(&gDebuggerNotificationLock);
// Let the thread do it's thing // Let the thread run.
pthread_mutex_unlock(start_mutex); pthread_mutex_unlock(start_mutex);
*thread_out = (pthread_t)thread; *thread_out = (pthread_t) thread;
return 0; return 0;
} }

4
libc/bionic/pthread_internal.h
View File

@ -41,12 +41,12 @@ typedef struct pthread_internal_t
pthread_cond_t join_cond; pthread_cond_t join_cond;
int join_count; int join_count;
void* return_value; void* return_value;
int intern; int internal_flags;
__pthread_cleanup_t* cleanup_stack; __pthread_cleanup_t* cleanup_stack;
void** tls; /* thread-local storage area */ void** tls; /* thread-local storage area */
} pthread_internal_t; } pthread_internal_t;
extern void _init_thread(pthread_internal_t * thread, pid_t kernel_id, pthread_attr_t * attr, void * stack_base); extern int _init_thread(pthread_internal_t * thread, pid_t kernel_id, pthread_attr_t * attr, void * stack_base);
void _pthread_internal_add( pthread_internal_t* thread ); void _pthread_internal_add( pthread_internal_t* thread );
pthread_internal_t* __get_thread(void); pthread_internal_t* __get_thread(void);