Updating check if waiting on futex can be canceled

In __timedwait_cp updating test whether waiting on futex can be canceled
(by calling pthread_cancel). This change allows to keep changes in musl
minimal.

Author: abujalski

src/library_pthread.js

@@ -171,19 +171,7 @@ var LibraryPThread = {
       if (ENVIRONMENT_IS_PTHREAD && threadInfoStruct) ___pthread_tsd_run_dtors();
     },
 
-    // Called when we are performing a pthread_exit(), either explicitly called by programmer,
-    // or implicitly when leaving the thread main function.
-    threadExit: function(exitCode) {
-      var tb = _pthread_self();
-      if (tb) { // If we haven't yet exited?
-#if ASSERTIONS
-        err('Pthread 0x' + tb.toString(16) + ' exited.');
-#endif
-#if PTHREADS_PROFILING
-        var profilerBlock = Atomics.load(HEAPU32, (threadInfoStruct + {{{ C_STRUCTS.pthread.profilerBlock }}} ) >> 2);
-        Atomics.store(HEAPU32, (threadInfoStruct + {{{ C_STRUCTS.pthread.profilerBlock }}} ) >> 2, 0);
-        _free(profilerBlock);
-#endif
+    onThreadExit: function(tb, exitCode) {
         // Disable all cancellation so that executing the cleanup handlers won't trigger another JS
         // canceled exception to be thrown.
         Atomics.store(HEAPU32, (tb + {{{ C_STRUCTS.pthread.canceldisable }}} ) >> 2, 1/*PTHREAD_CANCEL_DISABLE*/);
@@ -193,11 +181,28 @@ var LibraryPThread = {
         Atomics.store(HEAPU32, (tb + {{{ C_STRUCTS.pthread.threadExitCode }}} ) >> 2, exitCode);
         // When we publish this, the main thread is free to deallocate the thread object and we are done.
         // Therefore set threadInfoStruct = 0; above to 'release' the object in this worker thread.
-        Atomics.store(HEAPU32, (tb + {{{ C_STRUCTS.pthread.threadStatus }}} ) >> 2, 1);
+        Atomics.store(HEAPU32, (tb + {{{ C_STRUCTS.pthread.threadStatus }}} ) >> 2, 1); // Mark the thread as no longer running.
 
         _emscripten_futex_wake(tb + {{{ C_STRUCTS.pthread.threadStatus }}}, {{{ cDefine('INT_MAX') }}});
+        _emscripten_futex_wake(tb + {{{ C_STRUCTS.pthread.threadStatus }}}, {{{ cDefine('INT_MAX') }}}); // wake all threads
         __register_pthread_ptr(0, 0, 0); // Unregister the thread block also inside the asm.js scope.
         threadInfoStruct = 0;
+    },
+
+    // Called when we are performing a pthread_exit(), either explicitly called by programmer,
+    // or implicitly when leaving the thread main function.
+    threadExit: function(exitCode) {
+      var tb = _pthread_self();
+      if (tb) { // If we haven't yet exited?
+#if ASSERTIONS
+        err('Pthread 0x' + tb.toString(16) + ' exited.');
+#endif
+#if PTHREADS_PROFILING
+        var profilerBlock = Atomics.load(HEAPU32, (threadInfoStruct + {{{ C_STRUCTS.pthread.profilerBlock }}} ) >> 2);
+        Atomics.store(HEAPU32, (threadInfoStruct + {{{ C_STRUCTS.pthread.profilerBlock }}} ) >> 2, 0);
+        _free(profilerBlock);
+#endif
+        PThread.onThreadExit(tb, exitCode);
         if (ENVIRONMENT_IS_PTHREAD) {
           // Note: in theory we would like to return any offscreen canvases back to the main thread,
           // but if we ever fetched a rendering context for them that would not be valid, so we don't try.
@@ -207,16 +212,8 @@ var LibraryPThread = {
     },
 
     threadCancel: function() {
-      // Disable all cancellation so that executing the cleanup handlers won't trigger another JS
-      // canceled exception to be thrown.
-      Atomics.store(HEAPU32, (threadInfoStruct + {{{ C_STRUCTS.pthread.canceldisable }}} ) >> 2, 1/*PTHREAD_CANCEL_DISABLE*/);
-      Atomics.store(HEAPU32, (threadInfoStruct + {{{ C_STRUCTS.pthread.cancelasync }}} ) >> 2, 0/*PTHREAD_CANCEL_DEFERRED*/);
-      PThread.runExitHandlers();
-      Atomics.store(HEAPU32, (threadInfoStruct + {{{ C_STRUCTS.pthread.threadExitCode }}} ) >> 2, -1/*PTHREAD_CANCELED*/);
-      Atomics.store(HEAPU32, (threadInfoStruct + {{{ C_STRUCTS.pthread.threadStatus }}} ) >> 2, 1); // Mark the thread as no longer running.
-      _emscripten_futex_wake(threadInfoStruct + {{{ C_STRUCTS.pthread.threadStatus }}}, {{{ cDefine('INT_MAX') }}}); // wake all threads
-      threadInfoStruct = selfThreadId = 0; // Not hosting a pthread anymore in this worker, reset the info structures to null.
-      __register_pthread_ptr(0, 0, 0); // Unregister the thread block also inside the asm.js scope.
+      PThread.onThreadExit(threadInfoStruct, -1/*PTHREAD_CANCELED*/);
+      selfThreadId = 0;
       postMessage({ 'cmd': 'cancelDone' });
     },
 

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

@@ -42,10 +42,10 @@ int __timedwait_cp(volatile int *addr, int val,
 #ifdef __EMSCRIPTEN__
 	double msecsToSleep = top ? (top->tv_sec * 1000 + top->tv_nsec / 1000000.0) : INFINITY;
 	int is_main_thread = emscripten_is_main_browser_thread();
-	int can_cancel_wait = pthread_self()->canceldisable == PTHREAD_CANCEL_ENABLE ||
-		(pthread_self()->canceldisable == PTHREAD_CANCEL_MASKED &&
-		 pthread_self()->cancelasync == PTHREAD_CANCEL_ASYNCHRONOUS);
-	if (is_main_thread || can_cancel_wait) {
+	// 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
+	// which may be either done by the user of __timedwait() function.
+	if (is_main_thread || pthread_self()->canceldisable != PTHREAD_CANCEL_DISABLE) {
 		double sleepUntilTime = emscripten_get_now() + msecsToSleep;
 		do {
 			if (_pthread_isduecanceled(pthread_self())) {
@@ -83,13 +83,9 @@ int __timedwait(volatile int *addr, int val,
 	clockid_t clk, const struct timespec *at, int priv)
 {
 	int cs, r;
-
+	__pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cs);
 #ifdef __EMSCRIPTEN__
-	__pthread_setcancelstate(PTHREAD_CANCEL_MASKED, &cs);
-	if (cs == PTHREAD_CANCEL_DISABLE) __pthread_setcancelstate(cs, 0);
 	emscripten_conditional_set_current_thread_status(EM_THREAD_STATUS_RUNNING, EM_THREAD_STATUS_WAITMUTEX);
-#else
-	__pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cs);
 #endif
 	r = __timedwait_cp(addr, val, clk, at, priv);
 #ifdef __EMSCRIPTEN__

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

@@ -115,10 +115,8 @@ int __pthread_cond_timedwait(pthread_cond_t *restrict c, pthread_mutex_t *restri
 
 	__pthread_mutex_unlock(m);
 
-#ifndef __EMSCRIPTEN__
 	__pthread_setcancelstate(PTHREAD_CANCEL_MASKED, &cs);
 	if (cs == PTHREAD_CANCEL_DISABLE) __pthread_setcancelstate(cs, 0);
-#endif
 
 	do e = __timedwait_cp(fut, seq, clock, ts, !shared);
 	while (*fut==seq && (!e || e==EINTR));
@@ -182,9 +180,7 @@ int __pthread_cond_timedwait(pthread_cond_t *restrict c, pthread_mutex_t *restri
 	if (e == ECANCELED) e = 0;
 
 done:
-#ifndef __EMSCRIPTEN__
 	__pthread_setcancelstate(cs, 0);
-#endif
 
 	if (e == ECANCELED) {
 		__pthread_testcancel();