LibC+LibPthread: Implement function forwarding for libpthread

GCC will insert various calls to pthread functions when compiling
C++ code with static initializers, even when the user doesn't link
their program against libpthread explicitly.

This is used to make static initializers thread-safe, e.g. when
building a library that does not itself use thread functionality
and thus does not link against libpthread - but is intended to
be used with other code that does use libpthread explicitly.

This makes these symbols available in libc.

Userland/Libraries/LibPthread/CMakeLists.txt

@@ -1,4 +1,5 @@
 set(SOURCES
+    forward.cpp
     pthread.cpp
     pthread_once.cpp
     semaphore.cpp

Userland/Libraries/LibPthread/forward.cpp

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2021, Gunnar Beutner <gunnar@beutner.name>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <LibC/bits/pthread_forward.h>
+
+static const PthreadFunctions s_functions = {
+    .pthread_mutex_trylock = pthread_mutex_trylock,
+    .pthread_mutex_destroy = pthread_mutex_destroy,
+
+    .pthread_mutexattr_init = pthread_mutexattr_init,
+    .pthread_mutexattr_settype = pthread_mutexattr_settype,
+    .pthread_mutexattr_destroy = pthread_mutexattr_destroy,
+
+    .pthread_once = pthread_once,
+
+    .pthread_cond_broadcast = pthread_cond_broadcast,
+    .pthread_cond_init = pthread_cond_init,
+    .pthread_cond_signal = pthread_cond_signal,
+    .pthread_cond_wait = pthread_cond_wait,
+    .pthread_cond_destroy = pthread_cond_destroy,
+    .pthread_cond_timedwait = pthread_cond_timedwait,
+};
+
+[[gnu::constructor]] static void forward_pthread_functions()
+{
+    __init_pthread_forward(s_functions);
+}

Userland/Libraries/LibPthread/pthread.cpp

@@ -55,8 +55,6 @@ constexpr size_t highest_reasonable_stack_size = 8 * MiB; // That's the default
 #define __RETURN_PTHREAD_ERROR(rc) \
     return ((rc) < 0 ? -(rc) : 0)
 
-extern void (*__libc_pthread_key_destroy_for_current_thread)();
-
 extern "C" {
 
 static void* pthread_create_helper(void* (*routine)(void*), void* argument)
@@ -531,99 +529,31 @@ int pthread_cond_broadcast(pthread_cond_t* cond)
     return 0;
 }
 
-static constexpr int max_keys = PTHREAD_KEYS_MAX;
-
-typedef void (*KeyDestructor)(void*);
-
-struct KeyTable {
-    KeyDestructor destructors[max_keys] { nullptr };
-    int next { 0 };
-    pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
-};
-
-struct SpecificTable {
-    void* values[max_keys] { nullptr };
-};
-
-static KeyTable s_keys;
-
-__thread SpecificTable t_specifics;
+// libgcc expects this function to exist in libpthread, even
+// if it is not implemented.
+int pthread_cancel(pthread_t)
+{
+    TODO();
+}
 
 int pthread_key_create(pthread_key_t* key, KeyDestructor destructor)
 {
-    int ret = 0;
-    pthread_mutex_lock(&s_keys.mutex);
-    if (s_keys.next >= max_keys) {
-        ret = EAGAIN;
-    } else {
-        *key = s_keys.next++;
-        s_keys.destructors[*key] = destructor;
-        ret = 0;
-    }
-    pthread_mutex_unlock(&s_keys.mutex);
-    return ret;
+    return __pthread_key_create(key, destructor);
 }
 
 int pthread_key_delete(pthread_key_t key)
 {
-    if (key < 0 || key >= max_keys)
-        return EINVAL;
-    pthread_mutex_lock(&s_keys.mutex);
-    s_keys.destructors[key] = nullptr;
-    pthread_mutex_unlock(&s_keys.mutex);
-    return 0;
+    return __pthread_key_delete(key);
 }
 
 void* pthread_getspecific(pthread_key_t key)
 {
-    if (key < 0)
-        return nullptr;
-    if (key >= max_keys)
-        return nullptr;
-    return t_specifics.values[key];
+    return __pthread_getspecific(key);
 }
 
 int pthread_setspecific(pthread_key_t key, const void* value)
 {
-    if (key < 0)
-        return EINVAL;
-    if (key >= max_keys)
-        return EINVAL;
-
-    t_specifics.values[key] = const_cast<void*>(value);
-    return 0;
-}
-
-[[gnu::constructor]] static void set_libc_key_destructor()
-{
-    __libc_pthread_key_destroy_for_current_thread = __pthread_key_destroy_for_current_thread;
-}
-
-void __pthread_key_destroy_for_current_thread()
-{
-    // This function will either be called during exit_thread, for a pthread, or
-    // during global program shutdown for the main thread.
-
-    pthread_mutex_lock(&s_keys.mutex);
-    size_t num_used_keys = s_keys.next;
-
-    // Dr. POSIX accounts for weird key destructors setting their own key again.
-    // Or even, setting other unrelated keys? Odd, but whatever the Doc says goes.
-
-    for (size_t destruct_iteration = 0; destruct_iteration < PTHREAD_DESTRUCTOR_ITERATIONS; ++destruct_iteration) {
-        bool any_nonnull_destructors = false;
-        for (size_t key_index = 0; key_index < num_used_keys; ++key_index) {
-            void* value = exchange(t_specifics.values[key_index], nullptr);
-
-            if (value && s_keys.destructors[key_index]) {
-                any_nonnull_destructors = true;
-                (*s_keys.destructors[key_index])(value);
-            }
-        }
-        if (!any_nonnull_destructors)
-            break;
-    }
-    pthread_mutex_unlock(&s_keys.mutex);
+    return __pthread_setspecific(key, value);
 }
 
 int pthread_setname_np(pthread_t thread, const char* name)

Userland/Libraries/LibPthread/pthread.h

@@ -146,6 +146,4 @@ int pthread_rwlockattr_setpshared(pthread_rwlockattr_t*, int);
 
 int pthread_atfork(void (*prepare)(void), void (*parent)(void), void (*child)(void));
 
-void __pthread_key_destroy_for_current_thread();
-
 __END_DECLS