Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-11-10 18:21:04 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Userland/Libraries/LibC/bits/pthread_integration.h

51 lines
1.4 KiB
C
Raw Normal View History

LibC+LibPthread: Implement pthread_atfork() This required a bit of rearchitecture, as pthread_atfork() required a mutex, and duplicating a mutex impl for it was silly. As such, this patch moves some standalone bits of pthread into LibC and uses those to implement atfork(). It should be noted that for programs that don't use atfork(), this mechanism only costs two atomic loads (as opposed to the normal mutex lock+unlock) :^)
2021-02-14 18:34:18 +03:30
/*
* Copyright (c) 2021, the SerenityOS developers.
*
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt *
2021-04-22 01:24:48 -07:00
* SPDX-License-Identifier: BSD-2-Clause
LibC+LibPthread: Implement pthread_atfork() This required a bit of rearchitecture, as pthread_atfork() required a mutex, and duplicating a mutex impl for it was silly. As such, this patch moves some standalone bits of pthread into LibC and uses those to implement atfork(). It should be noted that for programs that don't use atfork(), this mechanism only costs two atomic loads (as opposed to the normal mutex lock+unlock) :^)
2021-02-14 18:34:18 +03:30
*/
#pragma once
#include <sys/cdefs.h>
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.
2021-04-17 18:38:32 +02:00
#include <sys/types.h>
LibC+LibPthread: Implement pthread_atfork() This required a bit of rearchitecture, as pthread_atfork() required a mutex, and duplicating a mutex impl for it was silly. As such, this patch moves some standalone bits of pthread into LibC and uses those to implement atfork(). It should be noted that for programs that don't use atfork(), this mechanism only costs two atomic loads (as opposed to the normal mutex lock+unlock) :^)
2021-02-14 18:34:18 +03:30
__BEGIN_DECLS
void __pthread_fork_prepare(void);
void __pthread_fork_child(void);
void __pthread_fork_parent(void);
void __pthread_fork_atfork_register_prepare(void (*)(void));
void __pthread_fork_atfork_register_parent(void (*)(void));
void __pthread_fork_atfork_register_child(void (*)(void));
LibC: Rewrite pthread_mutex pthread_mutex is now an actual "sleeping" mutex, and not just a spinlock! It still has a fast path that only uses atomics and (in the successful case) returns immediately without sleeping. In case of contention, it calls futex_wait(), which lets the kernel scheduler put this thread to sleep, *and* lets it know exactly when to consider scheduling it again.
2021-07-05 14:41:41 +03:00
int __pthread_mutex_init(pthread_mutex_t*, const pthread_mutexattr_t*);
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.
2021-04-17 18:38:32 +02:00
int __pthread_mutex_lock(pthread_mutex_t*);
LibC: Move the __pthread_mutex_trylock function to LibC Let's move this to LibC because the dynamic loader depends on this function.
2021-04-24 20:34:50 +02:00
int __pthread_mutex_trylock(pthread_mutex_t*);
LibC: Add __pthread_mutex_lock_pessimistic_np() This is a private function that locks the lock much like the regular pthread_mutex_lock(), but causes the corresponding unlock operation to always assume there may be other waiters. This is useful in case some waiters are made to wait on the mutex's futex directly, without going through pthread_mutex_lock(). This is going to be used by the condition variable implementation in the next commit.
2021-07-05 14:55:57 +03:00
int __pthread_mutex_lock_pessimistic_np(pthread_mutex_t*);
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.
2021-04-17 18:38:32 +02:00
int __pthread_mutex_unlock(pthread_mutex_t*);
typedef void (*KeyDestructor)(void*);
int __pthread_key_create(pthread_key_t*, KeyDestructor);
int __pthread_key_delete(pthread_key_t);
void* __pthread_getspecific(pthread_key_t);
int __pthread_setspecific(pthread_key_t, const void*);
LibC+LibPthread: Implement pthread_atfork() This required a bit of rearchitecture, as pthread_atfork() required a mutex, and duplicating a mutex impl for it was silly. As such, this patch moves some standalone bits of pthread into LibC and uses those to implement atfork(). It should be noted that for programs that don't use atfork(), this mechanism only costs two atomic loads (as opposed to the normal mutex lock+unlock) :^)
2021-02-14 18:34:18 +03:30
int __pthread_self();
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.
2021-04-17 18:38:32 +02:00
void __pthread_key_destroy_for_current_thread();
LibC+LibPthread: Implement pthread_atfork() This required a bit of rearchitecture, as pthread_atfork() required a mutex, and duplicating a mutex impl for it was silly. As such, this patch moves some standalone bits of pthread into LibC and uses those to implement atfork(). It should be noted that for programs that don't use atfork(), this mechanism only costs two atomic loads (as opposed to the normal mutex lock+unlock) :^)
2021-02-14 18:34:18 +03:30
#define __PTHREAD_MUTEX_NORMAL 0
#define __PTHREAD_MUTEX_RECURSIVE 1
#define __PTHREAD_MUTEX_INITIALIZER \
{ \
0, 0, 0, __PTHREAD_MUTEX_NORMAL \
}
LibC+LibPthread: Add PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP This is a common but non-standard way of initializing a pthread_mutex_t in recursive mode.
2021-07-05 22:53:31 +02:00
#define __PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP \
{ \
0, 0, 0, __PTHREAD_MUTEX_RECURSIVE \
}
LibC+LibPthread: Implement pthread_atfork() This required a bit of rearchitecture, as pthread_atfork() required a mutex, and duplicating a mutex impl for it was silly. As such, this patch moves some standalone bits of pthread into LibC and uses those to implement atfork(). It should be noted that for programs that don't use atfork(), this mechanism only costs two atomic loads (as opposed to the normal mutex lock+unlock) :^)
2021-02-14 18:34:18 +03:30
__END_DECLS
Reference in a new issue Copy permalink