Use pthread_{testcancel,join} from musl

This is mainly a non-functional change, except that we now only check
whether blocking is allowed for joinable threads. This means that
exited threads can be joined without any blocking.

Author: kleisauke

system/lib/libc/musl/src/thread/pthread_cancel.c

@@ -3,7 +3,6 @@
 #include "pthread_impl.h"
 #include "syscall.h"
 
-#ifndef __EMSCRIPTEN__
 hidden long __cancel(), __syscall_cp_asm(), __syscall_cp_c();
 
 long __cancel()
@@ -15,6 +14,7 @@ long __cancel()
 	return -ECANCELED;
 }
 
+#ifndef __EMSCRIPTEN__
 long __syscall_cp_asm(volatile void *, syscall_arg_t,
                       syscall_arg_t, syscall_arg_t, syscall_arg_t,
                       syscall_arg_t, syscall_arg_t, syscall_arg_t);
@@ -67,6 +67,7 @@ static void cancel_handler(int sig, siginfo_t *si, void *ctx)
 
 	__syscall(SYS_tkill, self->tid, SIGCANCEL);
 }
+#endif
 
 void __testcancel()
 {
@@ -75,6 +76,7 @@ void __testcancel()
 		__cancel();
 }
 
+#ifndef __EMSCRIPTEN__
 static void init_cancellation()
 {
 	struct sigaction sa = {

system/lib/libc/musl/src/thread/pthread_detach.c

@@ -3,10 +3,11 @@
 
 static int __pthread_detach(pthread_t t)
 {
-	// XXX EMSCRIPTEN: Add check for invalid (already joined) thread.  Again
-	// for the benefit of the conformance tests.
-	if (t->self != t)
-		return ESRCH;
+#ifdef __EMSCRIPTEN__
+	// Attempt to detach a thread which does not point to a valid thread, or
+	// does not exist anymore.
+	if (!t || t->self != t) return ESRCH;
+#endif
 	/* If the cas fails, detach state is either already-detached
 	 * or exiting/exited, and pthread_join will trap or cleanup. */
 	if (a_cas(&t->detach_state, DT_JOINABLE, DT_DETACHED) != DT_JOINABLE)
@@ -16,5 +17,6 @@ static int __pthread_detach(pthread_t t)
 
 weak_alias(__pthread_detach, pthread_detach);
 weak_alias(__pthread_detach, thrd_detach);
-// XXX EMSCRIPTEN: add extra alias for asan.
+#ifdef __EMSCRIPTEN__ // XXX Emscripten add an extra alias for ASan/LSan.
 weak_alias(__pthread_detach, emscripten_builtin_pthread_detach);
+#endif

system/lib/libc/musl/src/thread/pthread_join.c

@@ -7,21 +7,55 @@ static void dummy1(pthread_t t)
 }
 weak_alias(dummy1, __tl_sync);
 
+#ifdef __EMSCRIPTEN__ // XXX Emscripten add extern for __emscripten_thread_cleanup
+extern void __emscripten_thread_cleanup(pthread_t thread);
+#endif
+
 static int __pthread_timedjoin_np(pthread_t t, void **res, const struct timespec *at)
 {
+#ifdef __EMSCRIPTEN__
+	// Attempt to join a thread which does not point to a valid thread, or
+	// does not exist anymore.
+	if (!t || t->self != t) return ESRCH;
+	// Thread is attempting to join to itself.  Already detached threads are
+	// handled below by returning EINVAL instead.
+	if (t->detach_state != DT_DETACHED && __pthread_self() == t) return EDEADLK;
+#endif
 	int state, cs, r = 0;
 	__pthread_testcancel();
 	__pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cs);
 	if (cs == PTHREAD_CANCEL_ENABLE) __pthread_setcancelstate(cs, 0);
 	while ((state = t->detach_state) && r != ETIMEDOUT && r != EINVAL) {
+#ifdef __EMSCRIPTEN__
+		// The thread is (already) detached and therefore not joinable.
+		// This also handle cases where the thread becomes detached
+		// *during* the join.
+		if (state >= DT_DETACHED) {
+			// Even though the man page says this is undefined
+			// behaviour we ave several tests in the posixtest suite
+			// that depend on this.
+			r = EINVAL;
+			break;
+		}
+		// Check whether blocking is allowed when the state is joinable.
+		// This is not necessary for exited threads because they can be
+		// joined without blocking.
+		if (state == DT_JOINABLE) emscripten_check_blocking_allowed();
+#else
 		if (state >= DT_DETACHED) a_crash();
+#endif
 		r = __timedwait_cp(&t->detach_state, state, CLOCK_REALTIME, at, 1);
 	}
 	__pthread_setcancelstate(cs, 0);
 	if (r == ETIMEDOUT || r == EINVAL) return r;
 	__tl_sync(t);
 	if (res) *res = t->result;
+#ifdef __EMSCRIPTEN__
+	// Thread was exited during this call, be sure to clean it up.
+	if (state == DT_EXITED) __emscripten_thread_cleanup(t);
+#else // XXX Emscripten map_base unused
 	if (t->map_base) __munmap(t->map_base, t->map_size);
+#endif
 	return 0;
 }
 
@@ -38,3 +72,6 @@ static int __pthread_tryjoin_np(pthread_t t, void **res)
 weak_alias(__pthread_tryjoin_np, pthread_tryjoin_np);
 weak_alias(__pthread_timedjoin_np, pthread_timedjoin_np);
 weak_alias(__pthread_join, pthread_join);
+#ifdef __EMSCRIPTEN__ // XXX Emscripten add an extra alias for LSan
+weak_alias(__pthread_join, emscripten_builtin_pthread_join);
+#endif

system/lib/pthread/library_pthread.c

@@ -36,8 +36,6 @@
 
 #include "threading_internal.h"
 
-void __pthread_testcancel();
-
 int emscripten_pthread_attr_gettransferredcanvases(const pthread_attr_t* a, const char** str) {
   *str = a->_a_transferredcanvases;
   return 0;

system/lib/pthread/library_pthread_stub.c

@@ -206,6 +206,8 @@ int pthread_cancel(pthread_t thread) {
   return 0;
 }
 
+void pthread_testcancel() {}
+
 _Noreturn void __pthread_exit(void* status) {
    exit(0);
 }

system/lib/pthread/pthread_create.c

@@ -237,16 +237,14 @@ void _emscripten_thread_exit(void* result) {
    * call; the loser is responsible for freeing thread resources. */
   int state = a_cas(&self->detach_state, DT_JOINABLE, DT_EXITING);
 
-  // Mark the thread as no longer running.
-  // When we publish this, the main thread is free to deallocate the thread
-  // object and we are done.
   if (state == DT_DETACHED) {
-    self->detach_state = DT_EXITED;
     __emscripten_thread_cleanup(self);
   } else {
-    self->detach_state = DT_EXITING;
-    // wake any threads that might be waiting for us to exit
-    emscripten_futex_wake(&self->detach_state, INT_MAX);
+    // Mark the thread as no longer running, so it can be joined.
+    // Once we publish this, any threads that are waiting to join with us can
+    // proceed and this worker can be recycled and used on another thread.
+    a_store(&self->detach_state, DT_EXITED);
+    __wake(&self->detach_state, 1, 1); // Wake any joiner.
   }
 }
 

system/lib/pthread/pthread_join.c

@@ -5,6 +5,7 @@
 
 #include <assert.h>
 #include <emscripten.h>
+#include <emscripten/threading.h>
 #include <pthread.h>
 #include <stdio.h>
 
@@ -32,8 +33,12 @@ void *ThreadMain(void *arg) {
   // Delay to force the main thread to try and fail a few times before
   // succeeding.
   while (tries.load() < EXPECTED_TRIES) {}
+#else
+  // Delay a bit to force the main thread to actually block, as exited
+  // threads can be joined without blocking.
+  emscripten_thread_sleep(1000);
 #endif
-	pthread_exit((void*)0);
+  pthread_exit((void*)0);
 }
 
 pthread_t CreateThread() {

system/lib/pthread/pthread_testcancel.c

@@ -822,16 +822,12 @@ def get_files(self):
         'syscall_cp.c', 'tls.c',
         # TODO: Support this. See #12216.
         'pthread_setname_np.c',
-        # TODO: These could be moved away from JS in the upcoming musl upgrade.
-        'pthread_join.c', 'pthread_testcancel.c',
       ]
       libc_files += files_in_path(
         path='system/lib/pthread',
         filenames=[
           'library_pthread.c',
           'pthread_create.c',
-          'pthread_join.c',
-          'pthread_testcancel.c',
           'emscripten_proxy_main.c',
           'emscripten_thread_init.c',
           'emscripten_thread_state.S',