Make detached threads work better

This change adds a double linked list of threads, so that pthread_exit()
will know when it should call exit() from an orphaned child. This change
also improves ftrace and strace logging.

test/libc/thread/pthread_create_test.c

@@ -54,16 +54,11 @@ void TriggerSignal(void) {
 }
 
 static void *Increment(void *arg) {
-  ASSERT_EQ(EDEADLK, pthread_join(pthread_self(), 0));
   ASSERT_EQ(gettid(), pthread_getthreadid_np());
   TriggerSignal();
   return (void *)((uintptr_t)arg + 1);
 }
 
-TEST(pthread_create, joinSelfDeadlocks) {
-  ASSERT_EQ(EDEADLK, pthread_join(pthread_self(), 0));
-}
-
 TEST(pthread_create, testCreateReturnJoin) {
   void *rc;
   pthread_t id;
@@ -279,4 +274,7 @@ BENCH(pthread_create, bench) {
   EZBENCH2("CreateJoin", donothing, CreateJoin());
   EZBENCH2("CreateDetach", donothing, CreateDetach());
   EZBENCH2("CreateDetached", donothing, CreateDetached());
+  while (!pthread_orphan_np()) {
+    pthread_decimate_np();
+  }
 }

test/libc/thread/pthread_detach_test.c

@@ -19,10 +19,13 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/struct/sigaction.h"
 #include "libc/errno.h"
+#include "libc/intrin/strace.internal.h"
 #include "libc/sysv/consts/sa.h"
 #include "libc/sysv/consts/sig.h"
 #include "libc/testlib/testlib.h"
+#include "libc/thread/posixthread.internal.h"
 #include "libc/thread/thread.h"
+#include "third_party/nsync/dll.h"
 
 void OnUsr1(int sig, struct siginfo *si, void *vctx) {
   struct ucontext *ctx = vctx;
@@ -40,7 +43,6 @@ void TriggerSignal(void) {
 }
 
 static void *Increment(void *arg) {
-  ASSERT_EQ(EDEADLK, pthread_join(pthread_self(), 0));
   ASSERT_EQ(gettid(), pthread_getthreadid_np());
   TriggerSignal();
   return (void *)((uintptr_t)arg + 1);
@@ -50,6 +52,9 @@ TEST(pthread_detach, testCreateReturn) {
   pthread_t id;
   ASSERT_EQ(0, pthread_create(&id, 0, Increment, 0));
   ASSERT_EQ(0, pthread_detach(id));
+  while (!pthread_orphan_np()) {
+    pthread_decimate_np();
+  }
 }
 
 TEST(pthread_detach, testDetachUponCreation) {
@@ -58,4 +63,7 @@ TEST(pthread_detach, testDetachUponCreation) {
   ASSERT_EQ(0, pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED));
   ASSERT_EQ(0, pthread_create(0, &attr, Increment, 0));
   ASSERT_EQ(0, pthread_attr_destroy(&attr));
+  while (!pthread_orphan_np()) {
+    pthread_decimate_np();
+  }
 }

test/libc/thread/pthread_exit_test.c

@@ -0,0 +1,66 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8                                :vi│
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/runtime/runtime.h"
+#include "libc/testlib/subprocess.h"
+#include "libc/testlib/testlib.h"
+#include "libc/thread/thread.h"
+
+#define MAIN  150
+#define CHILD 170
+
+pthread_t main_thread;
+_Thread_local static int exit_code;
+
+void OnExit(void) {
+  _Exit(exit_code);
+}
+
+void *Worker(void *arg) {
+  ASSERT_EQ(0, pthread_join(main_thread, 0));
+  exit_code = CHILD;
+  pthread_exit(0);
+}
+
+TEST(pthread_exit, joinableOrphanedChild_runsAtexitHandlers) {
+  pthread_attr_t attr;
+  SPAWN(fork);
+  atexit(OnExit);
+  exit_code = MAIN;
+  main_thread = pthread_self();
+  ASSERT_EQ(0, pthread_attr_init(&attr));
+  ASSERT_EQ(0, pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE));
+  ASSERT_EQ(0, pthread_create(0, &attr, Worker, 0));
+  ASSERT_EQ(0, pthread_attr_destroy(&attr));
+  pthread_exit(0);
+  EXITS(CHILD);
+}
+
+TEST(pthread_exit, detachedOrphanedChild_runsAtexitHandlers) {
+  pthread_attr_t attr;
+  SPAWN(fork);
+  atexit(OnExit);
+  exit_code = MAIN;
+  main_thread = pthread_self();
+  ASSERT_EQ(0, pthread_attr_init(&attr));
+  ASSERT_EQ(0, pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED));
+  ASSERT_EQ(0, pthread_create(0, &attr, Worker, 0));
+  ASSERT_EQ(0, pthread_attr_destroy(&attr));
+  pthread_exit(0);
+  EXITS(CHILD);
+}

test/libc/thread/pthread_key_create_test.c

@@ -16,23 +16,56 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/atomic.h"
+#include "libc/intrin/kprintf.h"
 #include "libc/mem/mem.h"
+#include "libc/nexgen32e/nexgen32e.h"
 #include "libc/testlib/testlib.h"
 #include "libc/thread/thread.h"
 
-TEST(pthread_key_create, testRunsDtors_becauseNoLeakReport) {
-  void *x;
-  pthread_key_t key;
-  x = malloc(123);
-  EXPECT_EQ(0, pthread_key_create(&key, free));
-  EXPECT_EQ(0, pthread_setspecific(key, x));
-  EXPECT_EQ(x, pthread_getspecific(key));
-  x = malloc(123);
-  EXPECT_EQ(0, pthread_key_create(&key, free));
-  EXPECT_EQ(0, pthread_setspecific(key, x));
-  EXPECT_EQ(x, pthread_getspecific(key));
-  x = malloc(123);
-  EXPECT_EQ(0, pthread_key_create(&key, free));
-  EXPECT_EQ(0, pthread_setspecific(key, x));
-  EXPECT_EQ(x, pthread_getspecific(key));
+pthread_key_t mykey;
+int destructor_calls;
+
+void KeyDestructor(void *arg) {
+  EXPECT_EQ(0, pthread_getspecific(mykey));
+  ASSERT_EQ(31337, (intptr_t)arg);
+  ++destructor_calls;
+}
+
+void *Worker(void *arg) {
+  ASSERT_EQ(0, pthread_getspecific(mykey));
+  ASSERT_EQ(0, pthread_setspecific(mykey, (void *)31337));
+  ASSERT_EQ((void *)31337, pthread_getspecific(mykey));
+  return 0;
+}
+
+TEST(pthread_key_create, test) {
+  pthread_t th;
+  destructor_calls = 0;
+  ASSERT_EQ(0, pthread_key_create(&mykey, KeyDestructor));
+  ASSERT_EQ(0, pthread_setspecific(mykey, (void *)666));
+  ASSERT_EQ(0, pthread_create(&th, 0, Worker, 0));
+  ASSERT_EQ(0, pthread_join(th, 0));
+  ASSERT_EQ(1, destructor_calls);
+  ASSERT_EQ((void *)666, pthread_getspecific(mykey));
+  ASSERT_EQ(0, pthread_key_delete(mykey));
+}
+
+void KeyDestructorCraze(void *arg) {
+  EXPECT_EQ(0, pthread_getspecific(mykey));
+  ASSERT_EQ(31337, (intptr_t)arg);
+  EXPECT_EQ(0, pthread_setspecific(mykey, (void *)31337));
+  ++destructor_calls;
+}
+
+TEST(pthread_key_create, destructorKeepsSettingKey_willHalt) {
+  pthread_t th;
+  destructor_calls = 0;
+  ASSERT_EQ(0, pthread_key_create(&mykey, KeyDestructorCraze));
+  ASSERT_EQ(0, pthread_setspecific(mykey, (void *)666));
+  ASSERT_EQ(0, pthread_create(&th, 0, Worker, 0));
+  ASSERT_EQ(0, pthread_join(th, 0));
+  ASSERT_EQ(PTHREAD_DESTRUCTOR_ITERATIONS, destructor_calls);
+  ASSERT_EQ((void *)666, pthread_getspecific(mykey));
+  ASSERT_EQ(0, pthread_key_delete(mykey));
 }