Enable pthread mutex/cond/rw_lock to be used in Wasm Workers

By using the `CURRENT_THREAD_ID` abstraction that already exists in
musl these primitives "just work" for Wasm Workers now.

This includes a partial revert of #26345.

Author: sbc100

ChangeLog.md

@@ -26,6 +26,8 @@ See docs/process.md for more on how version tagging works.
 - The deprecated `EMSCRIPTEN` macro is now defined in `emscripten.h` rather than
   on the command line (`__EMSCRIPTEN__`, which is built into LLVM, should be
   used instead). (#26417)
+- Pthread mutex/cond/rwlock primitives now work from with Wasm Workers (and
+  between Wasm Workers and pthreads). (#26510)
 
 5.0.3 - 03/14/26
 ----------------

site/source/docs/api_reference/wasm_workers.rst

@@ -89,13 +89,15 @@ Pthreads and Wasm Workers share several similarities:
  * Both can use emscripten_futex_wait/wake API,
  * Both can use GCC __sync_* Atomics API,
  * Both can use C11 and C++11 Atomics APIs,
+ * Both can use pthread_mutex/pthread_cond/pthread_rwlock/pthread_once APIs.
  * Both types of threads have a local stack.
  * Both types of threads have thread-local storage (TLS) support via ``thread_local`` (C++11),
    ``_Thread_local`` (C11) and ``__thread`` (GNU11) keywords.
  * Both types of threads support TLS via explicitly linked in Wasm globals (see
    ``test/wasm_worker/wasm_worker_tls_wasm_assembly.c/.S`` for example code)
  * Both types of threads have a concept of a thread ID (``pthread_self()`` for pthreads,
-   ``emscripten_wasm_worker_self_id()`` for Wasm Workers)
+   ``emscripten_wasm_worker_self_id()`` for Wasm Workers).  `gettid()` works in
+   both contexts so is more portable.
  * Both types of threads can perform an event-based and an infinite loop programming model.
  * Both can use ``EM_ASM`` and ``EM_JS`` API to execute JS code on the calling thread.
  * Both can call out to JS library functions (linked in with ``--js-library`` directive) to

src/lib/libatomic.js

@@ -161,4 +161,23 @@ addToLibrary({
     navigator['hardwareConcurrency'],
 
   emscripten_atomics_is_lock_free: (width) => Atomics.isLockFree(width),
+
+#if (ASSERTIONS || !ALLOW_BLOCKING_ON_MAIN_THREAD) && !MINIMAL_RUNTIME
+  emscripten_check_blocking_allowed__deps: ['$warnOnce'],
+#endif
+  emscripten_check_blocking_allowed: () => {
+#if (ASSERTIONS || !ALLOW_BLOCKING_ON_MAIN_THREAD) && !MINIMAL_RUNTIME
+#if ENVIRONMENT_MAY_BE_NODE
+    if (ENVIRONMENT_IS_NODE) return;
+#endif
+
+    if (ENVIRONMENT_IS_WORKER) return; // Blocking in a worker/pthread is fine.
+
+    warnOnce('Blocking on the main thread is very dangerous, see https://emscripten.org/docs/porting/pthreads.html#blocking-on-the-main-browser-thread');
+#if !ALLOW_BLOCKING_ON_MAIN_THREAD
+    abort('Blocking on the main thread is not allowed by default. See https://emscripten.org/docs/porting/pthreads.html#blocking-on-the-main-browser-thread');
+#endif
+
+#endif
+  },
 });

src/lib/libpthread.js

@@ -904,25 +904,6 @@ var LibraryPThread = {
     return spawnThread(threadParams);
   },
 
-#if (ASSERTIONS || !ALLOW_BLOCKING_ON_MAIN_THREAD) && !MINIMAL_RUNTIME
-  emscripten_check_blocking_allowed__deps: ['$warnOnce'],
-#endif
-  emscripten_check_blocking_allowed: () => {
-#if (ASSERTIONS || !ALLOW_BLOCKING_ON_MAIN_THREAD) && !MINIMAL_RUNTIME
-#if ENVIRONMENT_MAY_BE_NODE
-    if (ENVIRONMENT_IS_NODE) return;
-#endif
-
-    if (ENVIRONMENT_IS_WORKER) return; // Blocking in a worker/pthread is fine.
-
-    warnOnce('Blocking on the main thread is very dangerous, see https://emscripten.org/docs/porting/pthreads.html#blocking-on-the-main-browser-thread');
-#if !ALLOW_BLOCKING_ON_MAIN_THREAD
-    abort('Blocking on the main thread is not allowed by default. See https://emscripten.org/docs/porting/pthreads.html#blocking-on-the-main-browser-thread');
-#endif
-
-#endif
-  },
-
   // This function is called by a pthread to signal that exit() was called and
   // that the entire process should exit.
   // This function is always called from a pthread, but is executed on the

system/lib/libc/musl/src/temp/__randname.c

@@ -11,7 +11,7 @@ char *__randname(char *template)
 	unsigned long r;
 
 	__clock_gettime(CLOCK_REALTIME, &ts);
-	r = ts.tv_sec + ts.tv_nsec + __pthread_self()->tid * 65537UL;
+	r = ts.tv_sec + ts.tv_nsec + CURRENT_THREAD_ID * 65537UL;
 
 	/* XXX EMSCRIPTEN: avoid repeating the same result when __clock_gettime does not change between calls. */
 	static unsigned int counter = 0;

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

@@ -82,7 +82,7 @@ int __pthread_cond_timedwait(pthread_cond_t *restrict c, pthread_mutex_t *restri
 	}
 #endif
 
-	if ((m->_m_type&15) && (m->_m_lock&INT_MAX) != __pthread_self()->tid)
+	if ((m->_m_type&15) && (m->_m_lock&INT_MAX) != CURRENT_THREAD_ID)
 		return EPERM;
 
 	if (ts && ts->tv_nsec >= 1000000000UL)

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

@@ -7,7 +7,7 @@ int pthread_mutex_consistent(pthread_mutex_t *m)
 	int own = old & 0x3fffffff;
 	if (!(m->_m_type & 4) || !own || !(old & 0x40000000))
 		return EINVAL;
-	if (own != __pthread_self()->tid)
+	if (own != CURRENT_THREAD_ID)
 		return EPERM;
 	a_and(&m->_m_lock, ~0x40000000);
 	return 0;

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

@@ -87,12 +87,12 @@ int __pthread_mutex_timedlock(pthread_mutex_t *restrict m, const struct timespec
 		if (!own && (!r || (type&4)))
 			continue;
 		if ((type&3) == PTHREAD_MUTEX_ERRORCHECK
-		    && own == __pthread_self()->tid)
+		    && own == CURRENT_THREAD_ID)
 			return EDEADLK;
 #if defined(__EMSCRIPTEN__) && !defined(NDEBUG)
 		// Extra check for deadlock in debug builds, but only if we would block
 		// forever (at == NULL).
-		assert(at || own != __pthread_self()->tid && "pthread mutex deadlock detected");
+		assert(at || own != CURRENT_THREAD_ID && "pthread mutex deadlock detected");
 #endif
 
 		a_inc(&m->_m_waiters);

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

@@ -5,7 +5,7 @@ int __pthread_rwlock_timedwrlock(pthread_rwlock_t *restrict rw, const struct tim
 #ifdef __EMSCRIPTEN__
 	/// XXX Emscripten: The spec allows detecting when multiple write locks would deadlock, which we do here to avoid hangs.
 	/// If attempting to lock the write lock that we already own, error out.
-	if (rw->_rw_wr_owner == __pthread_self()->tid) return EDEADLK;
+	if (rw->_rw_wr_owner == CURRENT_THREAD_ID) return EDEADLK;
 #endif
 	int r, t;
 
@@ -27,7 +27,7 @@ int __pthread_rwlock_timedwrlock(pthread_rwlock_t *restrict rw, const struct tim
 #ifdef __EMSCRIPTEN__
 	/// XXX Emscripten: The spec allows detecting when multiple write locks would deadlock, which we do here to avoid hangs.
 	/// Mark this thread as the owner of this write lock.
-	rw->_rw_wr_owner = __pthread_self()->tid;
+	rw->_rw_wr_owner = CURRENT_THREAD_ID;
 #endif
 	return r;
 }

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

@@ -6,7 +6,7 @@ int __pthread_rwlock_trywrlock(pthread_rwlock_t *rw)
 #ifdef __EMSCRIPTEN__
 	/// XXX Emscripten: The spec allows detecting when multiple write locks would deadlock, which we do here to avoid hangs.
 	/// Mark this thread to own the write lock, to ignore multiple attempts to lock.
-	rw->_rw_wr_owner = __pthread_self()->tid;
+	rw->_rw_wr_owner = CURRENT_THREAD_ID;
 #endif
 	return 0;
 }