[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

@@ -1217,6 +1217,12 @@ var LibraryPThread = {
   },
 
   $markAsFinished: (pthread_ptr) => {
+    // When this is reached via a message from the exiting thread, the thread
+    // may already 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[pthread_ptr]) return;
+    var state = {{{ makeGetValue('pthread_ptr', C_STRUCTS.pthread.detach_state, 'i32') }}};
+    if (state != {{{ cDefs.DT_EXITING }}} && state != {{{ cDefs.DT_EXITED }}}) return;
 #if PTHREADS_DEBUG
     dbg(`markAsFinished: ${ptrToString(pthread_ptr)}`);
 #endif

src/struct_info_generated.json

@@ -55,6 +55,8 @@
         "CSIZE": 48,
         "DT_CHR": 2,
         "DT_DIR": 4,
+        "DT_EXITED": 0,
+        "DT_EXITING": 1,
         "DT_LNK": 10,
         "DT_REG": 8,
         "E2BIG": 1,
@@ -1072,6 +1074,7 @@
         },
         "pthread": {
             "__size__": 120,
+            "detach_state": 28,
             "profilerBlock": 96,
             "stack": 48,
             "stack_size": 52,

src/struct_info_generated_wasm64.json

@@ -55,6 +55,8 @@
         "CSIZE": 48,
         "DT_CHR": 2,
         "DT_DIR": 4,
+        "DT_EXITED": 0,
+        "DT_EXITING": 1,
         "DT_LNK": 10,
         "DT_REG": 8,
         "E2BIG": 1,
@@ -1072,6 +1074,7 @@
         },
         "pthread": {
             "__size__": 216,
+            "detach_state": 52,
             "profilerBlock": 176,
             "stack": 80,
             "stack_size": 88,

src/struct_info_internal.json

@@ -4,8 +4,13 @@
     // ===========================================
     {
         "file": "pthread_impl.h",
+        "defines": [
+            "DT_EXITED",
+            "DT_EXITING"
+        ],
         "structs": {
             "pthread": [
+              "detach_state",
               "profilerBlock",
               "stack",
               "stack_size",

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')