[pthread] Don't let a stale "finished" message mark a reused thread in dlopen sync

With dynamic linking, a joinable thread posts CMD_MARK_AS_FINISHED to the
main thread as it exits, so that dlopen()'s sync skips it. A join cleans the
thread up as soon as it returns, possibly before that message is handled,
and a new thread created in the meantime can get the same pthread_t. The
late message then marked the new, running thread as finished, so every
later dlopen() skipped it and its calls into newly loaded modules trapped.

Only mark a thread if it is still known and has actually exited.

Fixes: #27841

Author: typedrat

src/lib/libpthread.js

@@ -86,6 +86,7 @@ var LibraryPThread = {
                    '$addOnPreRun',
 #if MAIN_MODULE
                    '$markAsFinished',
+                   '_emscripten_thread_has_exited',
 #endif
 #if !MINIMAL_RUNTIME && PTHREAD_POOL_SIZE && !PTHREAD_POOL_DELAY_LOAD
                    '$addRunDependency',
@@ -323,7 +324,12 @@ var LibraryPThread = {
             break;
 #if MAIN_MODULE
           case {{{ CMD_MARK_AS_FINISHED }}}:
-            markAsFinished(d.thread);
+            // By the time this arrives the thread may have been joined and
+            // cleaned up, and its pthread_t reused by a new thread that is
+            // still running, which must not be marked.
+            if (PThread.pthreads[d.thread] && __emscripten_thread_has_exited(d.thread)) {
+              markAsFinished(d.thread);
+            }
             break;
 #endif
           case {{{ CMD_LOADED }}}:

system/lib/pthread/library_pthread.c

@@ -104,6 +104,11 @@ int _emscripten_thread_is_valid(pthread_t thread) {
   return thread->self == thread;
 }
 
+int _emscripten_thread_has_exited(pthread_t thread) {
+  int state = thread->detach_state;
+  return state == DT_EXITING || state == DT_EXITED;
+}
+
 static void *dummy_tsd[1] = { 0 };
 weak_alias(dummy_tsd, __pthread_tsd_main);
 

system/lib/pthread/threading_internal.h

@@ -79,6 +79,9 @@ void _emscripten_thread_set_strongref(pthread_t thread);
 // we can pass more of the posixtest suite than vanilla musl.
 int _emscripten_thread_is_valid(pthread_t thread);
 
+// Whether a thread that hasn't been cleaned up yet has run to its end.
+int _emscripten_thread_has_exited(pthread_t thread);
+
 void _emscripten_thread_exit_joinable(pthread_t thread);
 void _emscripten_thread_exit(void* result);
 void _emscripten_process_dlopen_queue(void);

test/core/pthread/test_pthread_dlsync_reused.c

@@ -0,0 +1,70 @@
+// A joinable thread's "finished" message only reaches the main thread once it
+// returns to the event loop.  By then the main thread has joined that thread
+// and created a new one that reuses its pthread_t.  The late message must not
+// stop the new, still running thread from taking part in dlopen()'s sync.
+
+#include <assert.h>
+#include <dlfcn.h>
+#include <emscripten/eventloop.h>
+#include <emscripten/threading.h>
+#include <limits.h>
+#include <math.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef int (*func_t)();
+
+static pthread_t waiter;
+static _Atomic int go;
+static func_t (*side_func_address)();
+static int result;
+
+static void* noop(void* arg) { return NULL; }
+
+static void* wait_then_call(void* arg) {
+  while (!go) {
+    emscripten_futex_wait(&go, 0, INFINITY);
+  }
+  if (side_func_address) {
+    result = side_func_address()();
+  }
+  return NULL;
+}
+
+static void release_waiter() {
+  go = 1;
+  emscripten_futex_wake(&go, INT_MAX);
+  pthread_join(waiter, NULL);
+  go = 0;
+}
+
+static void load_and_call(void* arg) {
+  void* handle = dlopen("libside.so", RTLD_NOW);
+  assert(handle);
+  side_func_address = dlsym(handle, "side_func_address");
+  assert(side_func_address);
+  // The waiter traps here if dlopen() skipped it.
+  release_waiter();
+  assert(result == 43);
+  printf("done\n");
+  exit(0);
+}
+
+int main() {
+  // The new thread almost always gets the joined thread's block back, but
+  // retry rather than depend on it.
+  for (int i = 0; i < 10; i++) {
+    pthread_t joined;
+    pthread_create(&joined, NULL, noop, NULL);
+    pthread_join(joined, NULL);
+    pthread_create(&waiter, NULL, wait_then_call, NULL);
+    if (pthread_equal(waiter, joined)) {
+      emscripten_set_timeout(load_and_call, 100, NULL);
+      return 0;
+    }
+    release_waiter();
+  }
+  printf("no thread reused a joined thread's pthread_t\n");
+  return 1;
+}

test/test_core.py

@@ -9403,6 +9403,16 @@ def test_pthread_dlopen(self, args):
                  ['side module ctor', 'done\n', 'side module atexit'],
                  assert_all=True, cflags=args)
 
+  @needs_dylink
+  @requires_pthreads
+  def test_pthread_dlsync_reused(self):
+    self.cflags += ['-Wno-experimental', '-pthread']
+    self.build_dlfcn_lib(test_file('core/pthread/test_pthread_dlopen_side.c'))
+    self.cflags += ['--embed-file', 'libside.so@libside.so']
+    self.prep_dlfcn_main()
+    self.set_setting('EXIT_RUNTIME')
+    self.do_runf('core/pthread/test_pthread_dlsync_reused.c', 'done\n')
+
   @needs_dylink
   @requires_pthreads
   @flaky('https://github.com/emscripten-core/emscripten/issues/18887')

tools/native_sigs.py

@@ -540,6 +540,7 @@
   '_emscripten_stack_restore': '_p',
   '_emscripten_thread_exit': '_p',
   '_emscripten_thread_free_data': '_p',
+  '_emscripten_thread_has_exited': '_p',
   '_emscripten_thread_init': '_p_____',
   '_emscripten_thread_is_valid': '_p',
   '_emscripten_thread_mailbox_init': '_p',