Add support for PTHREAD_MUTEX_ROBUST (#24666)

This was mostly just a case of copying the robust list handling code
from the musl version of pthread_create.

Author: sbc100

system/lib/pthread/pthread_create.c

@@ -312,10 +312,29 @@ void _emscripten_thread_exit(void* result) {
   // Call into the musl function that runs destructors of all thread-specific data.
   __pthread_tsd_run_dtors();
 
-  if (!--libc.threads_minus_1) libc.need_locks = 0;
-
   __tl_lock();
 
+  /* Process robust list in userspace to handle non-pshared mutexes
+   * and the detached thread case where the robust list head will
+   * be invalid when the kernel would process it. */
+  __vm_lock();
+  volatile void *volatile *rp;
+  while ((rp=self->robust_list.head) && rp != &self->robust_list.head) {
+    pthread_mutex_t *m = (void *)((char *)rp
+      - offsetof(pthread_mutex_t, _m_next));
+    int waiters = m->_m_waiters;
+    int priv = (m->_m_type & 128) ^ 128;
+    self->robust_list.pending = rp;
+    self->robust_list.head = *rp;
+    int cont = a_swap(&m->_m_lock, 0x40000000);
+    self->robust_list.pending = 0;
+    if (cont < 0 || waiters)
+      __wake(&m->_m_lock, 1, priv);
+  }
+  __vm_unlock();
+
+  if (!--libc.threads_minus_1) libc.need_locks = 0;
+
   self->next->prev = self->prev;
   self->prev->next = self->next;
   self->prev = self->next = self;

test/other/codesize/test_codesize_minimal_pthreads.funcs

@@ -18,6 +18,8 @@ $__timedwait
 $__timedwait_cp
 $__tl_lock
 $__tl_unlock
+$__vm_lock
+$__vm_unlock
 $__wait
 $__wake
 $__wake

test/other/codesize/test_codesize_minimal_pthreads.size

@@ -1 +1 @@
-19402
+19526

test/other/codesize/test_codesize_minimal_pthreads_memgrowth.funcs

@@ -18,6 +18,8 @@ $__timedwait
 $__timedwait_cp
 $__tl_lock
 $__tl_unlock
+$__vm_lock
+$__vm_unlock
 $__wait
 $__wake
 $__wake

test/other/codesize/test_codesize_minimal_pthreads_memgrowth.size

@@ -1 +1 @@
-19403
+19527

test/pthread/test_pthread_mutex_robust.c

@@ -0,0 +1,41 @@
+#include <assert.h>
+#include <errno.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+pthread_mutex_t mtx;
+
+void* original_owner_thread(void* ptr) {
+  printf("[original owner] Setting lock...\n");
+  pthread_mutex_lock(&mtx);
+  printf("[original owner] Locked. Now exiting without unlocking.\n");
+  pthread_exit(NULL);
+}
+
+int main(void) {
+  pthread_mutexattr_t attr;
+  pthread_mutexattr_init(&attr);
+  pthread_mutexattr_setrobust(&attr, PTHREAD_MUTEX_ROBUST);
+
+  pthread_mutex_init(&mtx, &attr);
+
+  pthread_t thr;
+  pthread_create(&thr, NULL, original_owner_thread, NULL);
+  pthread_join(thr, NULL);
+
+  printf("[main] Attempting to lock the robust mutex.\n");
+  int rtn = pthread_mutex_lock(&mtx);
+  printf("[main] pthread_mutex_lock -> %s.\n", strerror(rtn));
+  assert(rtn == EOWNERDEAD && "expected EOWNERDEAD");
+  printf("[main] Now make the mutex consistent\n");
+  rtn = pthread_mutex_consistent(&mtx);
+  assert(rtn == 0);
+  printf("[main] Mutex is now consistent; unlocking\n");
+  rtn = pthread_mutex_unlock(&mtx);
+  assert(rtn == 0);
+
+  return 0;
+}

test/pthread/test_pthread_mutex_robust.out

@@ -0,0 +1,6 @@
+[original owner] Setting lock...
+[original owner] Locked. Now exiting without unlocking.
+[main] Attempting to lock the robust mutex.
+[main] pthread_mutex_lock -> Previous owner died.
+[main] Now make the mutex consistent
+[main] Mutex is now consistent; unlocking

test/test_core.py

@@ -2725,6 +2725,10 @@ def test_pthread_run_script(self):
     self.set_setting('EXIT_RUNTIME')
     self.do_runf('pthread/test_pthread_run_script.c')
 
+  @node_pthreads
+  def test_pthread_mutex_robust(self):
+    self.do_run_in_out_file_test('pthread/test_pthread_mutex_robust.c')
+
   @node_pthreads
   def test_pthread_wait32_notify(self):
     self.do_run_in_out_file_test('atomic/test_wait32_notify.c')