Move pthread_cancel to native code

Author: kleisauke

src/library_pthread.js

@@ -446,6 +446,7 @@ var LibraryPThread = {
   },
 
   __emscripten_thread_cleanup: function(thread) {
+    // Called when a thread needs to be cleaned up so it can be reused.
     if (!ENVIRONMENT_IS_PTHREAD) cleanupThread(thread);
     else postMessage({ 'cmd': 'cleanupThread', 'thread': thread });
   },
@@ -788,12 +789,12 @@ var LibraryPThread = {
 #endif
   },
 
-  pthread_kill__deps: ['$killThread', 'emscripten_main_browser_thread_id'],
+  pthread_kill__deps: ['emscripten_main_browser_thread_id'],
   pthread_kill: function(thread, signal) {
     if (signal < 0 || signal >= 65/*_NSIG*/) return {{{ cDefine('EINVAL') }}};
     if (thread === _emscripten_main_browser_thread_id()) {
       if (signal == 0) return 0; // signal == 0 is a no-op.
-      err('Main thread (id=' + thread + ') cannot be killed with pthread_kill!');
+      err('Main thread (id=0x' + thread.toString(16) + ') cannot be killed with pthread_kill!');
       return {{{ cDefine('ESRCH') }}};
     }
     if (!thread) {
@@ -802,38 +803,19 @@ var LibraryPThread = {
     }
     var self = {{{ makeGetValue('thread', C_STRUCTS.pthread.self, 'i32') }}};
     if (self !== thread) {
-      err('pthread_kill attempted on thread ' + thread + ', which does not point to a valid thread, or does not exist anymore!');
+      err('pthread_kill attempted on thread 0x' + thread.toString(16) + ', which does not point to a valid thread, or does not exist anymore!');
       return {{{ cDefine('ESRCH') }}};
     }
-    if (signal != 0) {
+    if (signal === {{{ cDefine('SIGCANCEL') }}}) { // Used by pthread_cancel in musl
+      if (!ENVIRONMENT_IS_PTHREAD) cancelThread(thread);
+      else postMessage({ 'cmd': 'cancelThread', 'thread': thread });
+    } else if (signal != 0) {
       if (!ENVIRONMENT_IS_PTHREAD) killThread(thread);
-      else postMessage({ 'cmd': 'killThread', 'thread': thread});
+      else postMessage({ 'cmd': 'killThread', 'thread': thread });
     }
     return 0;
   },
 
-  pthread_cancel__deps: ['$cancelThread', 'emscripten_main_browser_thread_id'],
-  pthread_cancel: function(thread) {
-    if (thread === _emscripten_main_browser_thread_id()) {
-      err('Main thread (id=' + thread + ') cannot be canceled!');
-      return {{{ cDefine('ESRCH') }}};
-    }
-    if (!thread) {
-      err('pthread_cancel attempted on a null thread pointer!');
-      return {{{ cDefine('ESRCH') }}};
-    }
-    var self = {{{ makeGetValue('thread', C_STRUCTS.pthread.self, 'i32') }}};
-    if (self !== thread) {
-      err('pthread_cancel attempted on thread ' + thread + ', which does not point to a valid thread, or does not exist anymore!');
-      return {{{ cDefine('ESRCH') }}};
-    }
-    // Signal the thread that it needs to cancel itself.
-    Atomics.store(HEAPU32, (thread + {{{ C_STRUCTS.pthread.cancel }}}) >> 2, 1);
-    if (!ENVIRONMENT_IS_PTHREAD) cancelThread(thread);
-    else postMessage({ 'cmd': 'cancelThread', 'thread': thread});
-    return 0;
-  },
-
   __pthread_detached_exit: function() {
     // Called at the end of pthread_exit (which occurs also when leaving the
     // thread main function) if an only if the thread is in a detached state.

src/struct_info_internal.json

@@ -31,7 +31,8 @@
             ]
         },
         "defines": [
-          "EM_THREAD_NAME_MAX"
+          "EM_THREAD_NAME_MAX",
+          "SIGCANCEL"
         ]
     },
     {

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

@@ -42,7 +42,9 @@ int __timedwait_cp(volatile int *addr, int val,
 	int r;
 	struct timespec to, *top=0;
 
+#ifndef __EMSCRIPTEN__
 	if (priv) priv = FUTEX_PRIVATE;
+#endif
 
 	if (at) {
 		if (at->tv_nsec >= 1000000000UL) return EINVAL;
@@ -56,17 +58,20 @@ int __timedwait_cp(volatile int *addr, int val,
 		top = &to;
 	}
 #ifdef __EMSCRIPTEN__
+	pthread_t self = __pthread_self();
 	double msecsToSleep = top ? (top->tv_sec * 1000 + top->tv_nsec / 1000000.0) : INFINITY;
 	int is_runtime_thread = emscripten_is_main_runtime_thread();
+
+	// Main runtime thread may need to run proxied calls, so sleep in very small slices to be responsive.
+	const double maxMsecsSliceToSleep = is_runtime_thread ? 1 : 100;
+
 	// cp suffix in the function name means "cancellation point", so this wait can be cancelled
-	// by the users unless current threads cancelability is set to PTHREAD_CANCEL_DISABLE
+	// by the users unless current threads cancellability is set to PTHREAD_CANCEL_DISABLE
 	// which may be either done by the user of __timedwait() function.
-	if (is_runtime_thread ||
-	    pthread_self()->canceldisable != PTHREAD_CANCEL_DISABLE ||
-	    pthread_self()->cancelasync == PTHREAD_CANCEL_ASYNCHRONOUS) {
+	if (is_runtime_thread || self->canceldisable != PTHREAD_CANCEL_DISABLE || self->cancelasync) {
 		double sleepUntilTime = emscripten_get_now() + msecsToSleep;
 		do {
-			if (pthread_self()->cancel) {
+			if (self->cancel) {
 				// Emscripten-specific return value: The wait was canceled by user calling
 				// pthread_cancel() for this thread, and the caller needs to cooperatively
 				// cancel execution.
@@ -80,8 +85,8 @@ int __timedwait_cp(volatile int *addr, int val,
 				r = ETIMEDOUT;
 				break;
 			}
-			if (waitMsecs > 100) waitMsecs = 100; // non-main threads can sleep in longer slices.
-			if (is_runtime_thread && waitMsecs > 1) waitMsecs = 1; // the runtime thread may need to run proxied calls, so sleep in very small slices to be responsive.
+			if (waitMsecs > maxMsecsSliceToSleep)
+				waitMsecs = maxMsecsSliceToSleep;
 			r = -emscripten_futex_wait((void*)addr, val, waitMsecs);
 		} while(r == ETIMEDOUT);
 	} else {
@@ -92,7 +97,7 @@ int __timedwait_cp(volatile int *addr, int val,
 	r = -__futex4_cp(addr, FUTEX_WAIT|priv, val, top);
 #endif
 	if (r != EINTR && r != ETIMEDOUT && r != ECANCELED) r = 0;
-#ifndef __EMSCRIPTEN__
+#ifndef __EMSCRIPTEN__ // XXX Emscripten revert musl commit a63c0104e496f7ba78b64be3cd299b41e8cd427f
 	/* Mitigate bug in old kernels wrongly reporting EINTR for non-
 	 * interrupting (SA_RESTART) signal handlers. This is only practical
 	 * when NO interrupting signal handlers have been installed, and

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

@@ -8,28 +8,33 @@
 void __wait(volatile int *addr, volatile int *waiters, int val, int priv)
 {
 	int spins=100;
+#ifndef __EMSCRIPTEN__
 	if (priv) priv = FUTEX_PRIVATE;
+#endif
 	while (spins-- && (!waiters || !*waiters)) {
 		if (*addr==val) a_spin();
 		else return;
 	}
 	if (waiters) a_inc(waiters);
 #ifdef __EMSCRIPTEN__
+	pthread_t self = __pthread_self();
 	int is_runtime_thread = emscripten_is_main_runtime_thread();
+
+	// Main runtime thread may need to run proxied calls, so sleep in very small slices to be responsive.
+	const double maxMsecsSliceToSleep = is_runtime_thread ? 1 : 100;
+
 	while (*addr==val) {
-		if (is_runtime_thread || pthread_self()->cancelasync == PTHREAD_CANCEL_ASYNCHRONOUS) {
+		if (is_runtime_thread || self->cancelasync) {
 			// Must wait in slices in case this thread is cancelled in between.
 			int e;
 			do {
-				if (pthread_self()->cancel) {
+				if (self->cancel) {
 					if (waiters) a_dec(waiters);
 					return;
 				}
 				// Assist other threads by executing proxied operations that are effectively singlethreaded.
 				if (is_runtime_thread) emscripten_main_thread_process_queued_calls();
-				// Main thread waits in _very_ small slices so that it stays responsive to assist proxied
-				// pthread calls.
-				e = emscripten_futex_wait((void*)addr, val, is_runtime_thread ? 1 : 100);
+				e = emscripten_futex_wait((void*)addr, val, maxMsecsSliceToSleep);
 			} while(e == -ETIMEDOUT);
 		} else {
 			// Can wait in one go.

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

@@ -3,7 +3,11 @@
 #include "pthread_impl.h"
 #include "syscall.h"
 
+#ifdef __EMSCRIPTEN__
+hidden long __cancel();
+#else
 hidden long __cancel(), __syscall_cp_asm(), __syscall_cp_c();
+#endif
 
 long __cancel()
 {
@@ -14,6 +18,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);
@@ -66,6 +71,7 @@ static void cancel_handler(int sig, siginfo_t *si, void *ctx)
 
 	__syscall(SYS_tkill, self->tid, SIGCANCEL);
 }
+#endif
 
 void __testcancel()
 {
@@ -74,6 +80,7 @@ void __testcancel()
 		__cancel();
 }
 
+#ifndef __EMSCRIPTEN__
 static void init_cancellation()
 {
 	struct sigaction sa = {
@@ -83,14 +90,17 @@ static void init_cancellation()
 	memset(&sa.sa_mask, -1, _NSIG/8);
 	__libc_sigaction(SIGCANCEL, &sa, 0);
 }
+#endif
 
 int pthread_cancel(pthread_t t)
 {
+#ifndef __EMSCRIPTEN__
 	static int init;
 	if (!init) {
 		init_cancellation();
 		init = 1;
 	}
+#endif
 	a_store(&t->cancel, 1);
 	if (t == pthread_self()) {
 		if (t->canceldisable == PTHREAD_CANCEL_ENABLE && t->cancelasync)

system/lib/pthread/pthread_create.c

@@ -22,7 +22,7 @@
 
 // See musl's pthread_create.c
 
-extern int __pthread_create_js(struct pthread *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);
+extern int __pthread_create_js(pthread_t thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);
 extern void _emscripten_thread_init(int, int, int);
 extern int _emscripten_default_pthread_stack_size();
 extern void __pthread_detached_exit();
@@ -76,7 +76,7 @@ int __pthread_create(pthread_t* restrict res,
                      void* (*entry)(void*),
                      void* restrict arg) {
   // Note on LSAN: lsan intercepts/wraps calls to pthread_create so any
-  // allocation we we do here should be considered leaks.
+  // allocation we do here should be considered as leak.
   // See: lsan_interceptors.cpp.
   if (!res) {
     return EINVAL;
@@ -188,11 +188,11 @@ static void free_tls_data() {
 }
 
 void _emscripten_thread_exit(void* result) {
-  struct pthread *self = __pthread_self();
+  pthread_t self = __pthread_self();
   assert(self);
 
-  self->canceldisable = PTHREAD_CANCEL_DISABLE;
-  self->cancelasync = PTHREAD_CANCEL_DEFERRED;
+  self->canceldisable = 1;
+  self->cancelasync = 0;
   self->result = result;
 
   // Run any handlers registered with pthread_cleanup_push
@@ -219,16 +219,16 @@ void _emscripten_thread_exit(void* result) {
     return;
   }
 
-  // We have the call the buildin free here since lsan handling for this thread
+  // We have the call the builtin free here since lsan handling for this thread
   // gets shut down during __pthread_tsd_run_dtors.
   emscripten_builtin_free(self->tsd);
   self->tsd = NULL;
 
   // Not hosting a pthread anymore in this worker set __pthread_self to NULL
   _emscripten_thread_init(0, 0, 0);
 
-  /* This atomic potentially competes with a concurrent pthread_detach
-   * call; the loser is responsible for freeing thread resources. */
+  // This atomic potentially competes with a concurrent pthread_detach
+  // 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.
@@ -244,7 +244,7 @@ void _emscripten_thread_exit(void* result) {
   }
 }
 
-// Mark as `no_sanitize("address"` since emscripten_pthread_exit destroys
+// Mark as `no_sanitize("address")` since emscripten_pthread_exit destroys
 // the current thread and runs its exit handlers.  Without this asan injects
 // a call to __asan_handle_no_return before emscripten_unwind_to_js_event_loop
 // which seem to cause a crash later down the line.

tests/reference_struct_info.json

@@ -320,6 +320,7 @@
         "SEEK_END": 2,
         "SEEK_SET": 0,
         "SIGALRM": 14,
+        "SIGCANCEL": 33,
         "SOCK_CLOEXEC": 524288,
         "SOCK_DGRAM": 2,
         "SOCK_NONBLOCK": 2048,

tools/system_libs.py

@@ -815,7 +815,6 @@ def get_files(self):
         # TODO: Support this. See #12216.
         'pthread_setname_np.c',
         # TODO: These could be moved away from JS in the upcoming musl upgrade.
-        'pthread_cancel.c',
         'pthread_join.c', 'pthread_testcancel.c',
       ]
       libc_files += files_in_path(