X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=src%2Fthread%2Fpthread_create.c;h=ee6c31c46c156af22ef3774a64493544276eb0ed;hb=d8e283df58eb8bff1aa2f8a99347e294c7f67cb9;hp=6a37ee9be5c760a89923a394276406a027a45e22;hpb=6e531f999a82cf39a951e1e9bba3cb80a6eb1464;p=musl

diff --git a/src/thread/pthread_create.c b/src/thread/pthread_create.c
index 6a37ee9b..ee6c31c4 100644
--- a/src/thread/pthread_create.c
+++ b/src/thread/pthread_create.c
@@ -1,5 +1,7 @@
+#define _GNU_SOURCE
 #include "pthread_impl.h"
 #include "stdio_impl.h"
+#include "libc.h"
 #include <sys/mman.h>
 
 static void dummy_0()
@@ -12,7 +14,7 @@ weak_alias(dummy_0, __pthread_tsd_run_dtors);
 _Noreturn void pthread_exit(void *result)
 {
 	pthread_t self = pthread_self();
-	int n;
+	sigset_t set;
 
 	self->result = result;
 
@@ -30,17 +32,30 @@ _Noreturn void pthread_exit(void *result)
 	/* Mark this thread dead before decrementing count */
 	__lock(self->killlock);
 	self->dead = 1;
-	__unlock(self->killlock);
 
 	/* Block all signals before decrementing the live thread count.
 	 * This is important to ensure that dynamically allocated TLS
 	 * is not under-allocated/over-committed, and possibly for other
 	 * reasons as well. */
-	__syscall(SYS_rt_sigprocmask, SIG_BLOCK, SIGALL_SET, 0, _NSIG/8);
+	__block_all_sigs(&set);
+
+	/* Wait to unlock the kill lock, which governs functions like
+	 * pthread_kill which target a thread id, until signals have
+	 * been blocked. This precludes observation of the thread id
+	 * as a live thread (with application code running in it) after
+	 * the thread was reported dead by ESRCH being returned. */
+	__unlock(self->killlock);
 
-	do n = libc.threads_minus_1;
-	while (n && a_cas(&libc.threads_minus_1, n, n-1)!=n);
-	if (!n) exit(0);
+	/* It's impossible to determine whether this is "the last thread"
+	 * until performing the atomic decrement, since multiple threads
+	 * could exit at the same time. For the last thread, revert the
+	 * decrement and unblock signals to give the atexit handlers and
+	 * stdio cleanup code a consistent state. */
+	if (a_fetch_add(&libc.threads_minus_1, -1)==0) {
+		libc.threads_minus_1 = 0;
+		__restore_sigs(&set);
+		exit(0);
+	}
 
 	if (self->detached && self->map_base) {
 		/* Detached threads must avoid the kernel clear_child_tid
@@ -81,8 +96,7 @@ static int start(void *p)
 			self->detached = 2;
 			pthread_exit(0);
 		}
-		__syscall(SYS_rt_sigprocmask, SIG_SETMASK,
-			self->sigmask, 0, _NSIG/8);
+		__restore_sigs(self->sigmask);
 	}
 	if (self->unblock_cancel)
 		__syscall(SYS_rt_sigprocmask, SIG_UNBLOCK,
@@ -115,7 +129,9 @@ int pthread_create(pthread_t *restrict res, const pthread_attr_t *restrict attrp
 	size_t size, guard;
 	struct pthread *self = pthread_self(), *new;
 	unsigned char *map = 0, *stack = 0, *tsd = 0, *stack_limit;
-	unsigned flags = 0x7d8f00;
+	unsigned flags = CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND
+		| CLONE_THREAD | CLONE_SYSVSEM | CLONE_SETTLS
+		| CLONE_PARENT_SETTID | CLONE_CHILD_CLEARTID | CLONE_DETACHED;
 	int do_sched = 0;
 	pthread_attr_t attr = {0};
 
@@ -185,12 +201,11 @@ int pthread_create(pthread_t *restrict res, const pthread_attr_t *restrict attrp
 	new->tsd = (void *)tsd;
 	if (attr._a_detach) {
 		new->detached = 1;
-		flags -= 0x200000;
+		flags -= CLONE_CHILD_CLEARTID;
 	}
 	if (attr._a_sched) {
 		do_sched = new->startlock[0] = 1;
-		__syscall(SYS_rt_sigprocmask, SIG_BLOCK,
-			SIGALL_SET, self->sigmask, _NSIG/8);
+		__block_app_sigs(new->sigmask);
 	}
 	new->unblock_cancel = self->cancel;
 	new->canary = self->canary;
@@ -201,8 +216,7 @@ int pthread_create(pthread_t *restrict res, const pthread_attr_t *restrict attrp
 	__release_ptc();
 
 	if (do_sched) {
-		__syscall(SYS_rt_sigprocmask, SIG_SETMASK,
-			new->sigmask, 0, _NSIG/8);
+		__restore_sigs(new->sigmask);
 	}
 
 	if (ret < 0) {