X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=src%2Fthread%2Fpthread_create.c;h=6cbf85b32e052342032a09fc2e0f43530a9b7f25;hb=8c4be3e2209d2a1d3874b8bc2b474668fcbbbac6;hp=893773fa10f0228be9d64af7e1e884dcb048391c;hpb=12e1e324683a1d381b7f15dd36c99b37dd44d940;p=musl diff --git a/src/thread/pthread_create.c b/src/thread/pthread_create.c index 893773fa..6cbf85b3 100644 --- a/src/thread/pthread_create.c +++ b/src/thread/pthread_create.c @@ -9,8 +9,6 @@ void *__mmap(void *, size_t, int, int, int, off_t); int __munmap(void *, size_t); int __mprotect(void *, size_t, int); -void __vm_lock_impl(int); -void __vm_unlock_impl(void); static void dummy_0() { @@ -19,6 +17,7 @@ weak_alias(dummy_0, __acquire_ptc); weak_alias(dummy_0, __release_ptc); weak_alias(dummy_0, __pthread_tsd_run_dtors); weak_alias(dummy_0, __do_orphaned_stdio_locks); +weak_alias(dummy_0, __dl_thread_cleanup); _Noreturn void __pthread_exit(void *result) { @@ -68,16 +67,10 @@ _Noreturn void __pthread_exit(void *result) exit(0); } - if (self->locale != &libc.global_locale) { - a_dec(&libc.uselocale_cnt); - if (self->locale->ctype_utf8) - a_dec(&libc.bytelocale_cnt_minus_1); - } - /* Process robust list in userspace to handle non-pshared mutexes * and the detached thread case where the robust list head will * be invalid when the kernel would process it. */ - __vm_lock_impl(+1); + __vm_lock(); volatile void *volatile *rp; while ((rp=self->robust_list.head) && rp != &self->robust_list.head) { pthread_mutex_t *m = (void *)((char *)rp @@ -86,14 +79,15 @@ _Noreturn void __pthread_exit(void *result) int priv = (m->_m_type & 128) ^ 128; self->robust_list.pending = rp; self->robust_list.head = *rp; - int cont = a_swap(&m->_m_lock, self->tid|0x40000000); + int cont = a_swap(&m->_m_lock, 0x40000000); self->robust_list.pending = 0; if (cont < 0 || waiters) __wake(&m->_m_lock, 1, priv); } - __vm_unlock_impl(); + __vm_unlock(); __do_orphaned_stdio_locks(); + __dl_thread_cleanup(); if (self->detached && self->map_base) { /* Detached threads must avoid the kernel clear_child_tid @@ -110,6 +104,10 @@ _Noreturn void __pthread_exit(void *result) if (self->robust_list.off) __syscall(SYS_set_robust_list, 0, 3*sizeof(long)); + /* Since __unmapself bypasses the normal munmap code path, + * explicitly wait for vmlock holders first. */ + __vm_wait(); + /* The following call unmaps the thread's stack mapping * and then exits without touching the stack. */ __unmapself(self->map_base, self->map_size); @@ -120,7 +118,6 @@ _Noreturn void __pthread_exit(void *result) void __do_cleanup_push(struct __ptcb *cb) { - if (!libc.has_thread_pointer) return; struct pthread *self = __pthread_self(); cb->__next = self->cancelbuf; self->cancelbuf = cb; @@ -128,16 +125,20 @@ void __do_cleanup_push(struct __ptcb *cb) void __do_cleanup_pop(struct __ptcb *cb) { - if (!libc.has_thread_pointer) return; __pthread_self()->cancelbuf = cb->__next; } static int start(void *p) { pthread_t self = p; + /* States for startlock: + * 0 = no need for start sync + * 1 = waiting for parent to do work + * 2 = failure in parent, child must abort + * 3 = success in parent, child must restore sigmask */ if (self->startlock[0]) { __wait(self->startlock, 0, 1, 1); - if (self->startlock[0]) { + if (self->startlock[0] == 2) { self->detached = 2; pthread_exit(0); } @@ -167,6 +168,8 @@ static void *dummy_tsd[1] = { 0 }; weak_alias(dummy_tsd, __pthread_tsd_main); volatile int __block_new_threads = 0; +size_t __default_stacksize = DEFAULT_STACK_SIZE; +size_t __default_guardsize = DEFAULT_GUARD_SIZE; static FILE *volatile dummy_file = 0; weak_alias(dummy_file, __stdin_used); @@ -190,13 +193,14 @@ int __pthread_create(pthread_t *restrict res, const pthread_attr_t *restrict att | CLONE_THREAD | CLONE_SYSVSEM | CLONE_SETTLS | CLONE_PARENT_SETTID | CLONE_CHILD_CLEARTID | CLONE_DETACHED; int do_sched = 0; - pthread_attr_t attr = {0}; + pthread_attr_t attr = { 0 }; if (!libc.can_do_threads) return ENOSYS; self = __pthread_self(); if (!libc.threaded) { - for (FILE *f=libc.ofl_head; f; f=f->next) + for (FILE *f=*__ofl_lock(); f; f=f->next) init_file_lock(f); + __ofl_unlock(); init_file_lock(__stdin_used); init_file_lock(__stdout_used); init_file_lock(__stderr_used); @@ -207,11 +211,16 @@ int __pthread_create(pthread_t *restrict res, const pthread_attr_t *restrict att if (attrp && !c11) attr = *attrp; __acquire_ptc(); + if (!attrp || c11) { + attr._a_stacksize = __default_stacksize; + attr._a_guardsize = __default_guardsize; + } + if (__block_new_threads) __wait(&__block_new_threads, 0, 1, 1); if (attr._a_stackaddr) { size_t need = libc.tls_size + __pthread_tsd_size; - size = attr._a_stacksize + DEFAULT_STACK_SIZE; + size = attr._a_stacksize; stack = (void *)(attr._a_stackaddr & -16); stack_limit = (void *)(attr._a_stackaddr - size); /* Use application-provided stack for TLS only when @@ -226,8 +235,8 @@ int __pthread_create(pthread_t *restrict res, const pthread_attr_t *restrict att guard = 0; } } else { - guard = ROUND(DEFAULT_GUARD_SIZE + attr._a_guardsize); - size = guard + ROUND(DEFAULT_STACK_SIZE + attr._a_stacksize + guard = ROUND(attr._a_guardsize); + size = guard + ROUND(attr._a_stacksize + libc.tls_size + __pthread_tsd_size); } @@ -235,7 +244,8 @@ int __pthread_create(pthread_t *restrict res, const pthread_attr_t *restrict att if (guard) { map = __mmap(0, size, PROT_NONE, MAP_PRIVATE|MAP_ANON, -1, 0); if (map == MAP_FAILED) goto fail; - if (__mprotect(map+guard, size-guard, PROT_READ|PROT_WRITE)) { + if (__mprotect(map+guard, size-guard, PROT_READ|PROT_WRITE) + && errno != ENOSYS) { __munmap(map, size); goto fail; } @@ -268,8 +278,9 @@ int __pthread_create(pthread_t *restrict res, const pthread_attr_t *restrict att do_sched = new->startlock[0] = 1; __block_app_sigs(new->sigmask); } + new->robust_list.head = &new->robust_list.head; new->unblock_cancel = self->cancel; - new->canary = self->canary; + new->CANARY = self->CANARY; a_inc(&libc.threads_minus_1); ret = __clone((c11 ? start_c11 : start), stack, flags, new, &new->tid, TP_ADJ(new), &new->tid); @@ -289,7 +300,7 @@ int __pthread_create(pthread_t *restrict res, const pthread_attr_t *restrict att if (do_sched) { ret = __syscall(SYS_sched_setscheduler, new->tid, attr._a_policy, &attr._a_prio); - a_store(new->startlock, ret<0 ? 2 : 0); + a_store(new->startlock, ret<0 ? 2 : 3); __wake(new->startlock, 1, 1); if (ret < 0) return -ret; }