RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-26 01:57:45 +00:00
Code Issues Activity Actions

LibC+LibPthread: Implement function forwarding for libpthread

Browse source 
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.
This commit is contained in:
Gunnar Beutner 2021-04-17 18:38:32 +02:00 • committed by Andreas Kling
parent db3fd11646
commit 88cebb05ad
14 changed files with 381 additions and 100 deletions
Download patch file Download diff file Expand all files Collapse all files

90
Userland/Libraries/LibPthread/pthread.cpp
View file

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