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

@@ -30,6 +30,8 @@ See docs/process.md for more on how version tagging works.
   This is an extension of #26336 which removed many of them.  These APIs were
   not previously functional under Wasm Workers, but if there is strong use case
   it may be possible to enable them in future. (#26487)
+- 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;
 }