LadybirdBrowser/ladybird
1
1
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-11-10 13:00:29 +03:00
Code Issues Packages Projects Releases Wiki Activity
e2f242a552
ladybird/Userland/Libraries/LibC/pthread.h

150 lines
5.5 KiB
C
Raw Normal View History

Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 11:38:21 +03:00
/*
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
*
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 11:24:48 +03:00
* SPDX-License-Identifier: BSD-2-Clause
Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 11:38:21 +03:00
*/
LibC: Add dummy pthread.h for GCC build.
2019-04-27 22:19:18 +03:00
#pragma once
LibC: Add most of the "header may make visible" dependencies from POSIX
2023-07-15 16:22:45 +03:00
// Includes essentially mandated by POSIX:
// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/pthread.h.html
LibC: Add dummy pthread.h for GCC build.
2019-04-27 22:19:18 +03:00
#include <sched.h>
LibC: Add most of the "header may make visible" dependencies from POSIX
2023-07-15 16:22:45 +03:00
#include <time.h>
#include <bits/pthread_integration.h>
LibPthread: Implement a basic first pthread mutex This patch adds these API's: - pthread_mutex_init() - pthread_mutex_lock() - pthread_mutex_unlock() No mutex attributes are supported yet, so we only do the simplest mutex wihout recursive locking.
2019-11-16 14:19:58 +03:00
#include <stdint.h>
Add clang-format file Also run it across the whole tree to get everything using the One True Style. We don't yet run this in an automated fashion as it's a little slow, but there is a snippet to do so in makeall.sh.
2019-05-28 12:53:16 +03:00
#include <sys/cdefs.h>
Kernel+LibPthread: pthread_create handles pthread_attr_t Add an initial implementation of pthread attributes for: * detach state (joinable, detached) * schedule params (just priority) * guard page size (as skeleton) (requires kernel support maybe?) * stack size and user-provided stack location (4 or 8 MB only, must be aligned) Add some tests too, to the thread test program. Also, LibC: Move pthread declarations to sys/types.h, where they belong.
2019-11-18 06:08:10 +03:00
#include <sys/types.h>
LibC: Add dummy pthread.h for GCC build.
2019-04-27 22:19:18 +03:00
__BEGIN_DECLS
LibC: Make 'attributes' parameter for pthread_create const
2022-10-23 11:38:05 +03:00
int pthread_create(pthread_t*, pthread_attr_t const*, void* (*)(void*), void*);
Meta+LibHTTP through LibWeb: Make clang-format-10 clean
2020-09-18 10:49:51 +03:00
void pthread_exit(void*) __attribute__((noreturn));
LibC: Add dummy pthread.h for GCC build.
2019-04-27 22:19:18 +03:00
int pthread_kill(pthread_t, int);
Add clang-format file Also run it across the whole tree to get everything using the One True Style. We don't yet run this in an automated fashion as it's a little slow, but there is a snippet to do so in makeall.sh.
2019-05-28 12:53:16 +03:00
void pthread_cleanup_push(void (*)(void*), void*);
LibC: Add dummy pthread.h for GCC build.
2019-04-27 22:19:18 +03:00
void pthread_cleanup_pop(int);
int pthread_join(pthread_t, void**);
int pthread_mutex_lock(pthread_mutex_t*);
Add clang-format file Also run it across the whole tree to get everything using the One True Style. We don't yet run this in an automated fashion as it's a little slow, but there is a snippet to do so in makeall.sh.
2019-05-28 12:53:16 +03:00
int pthread_mutex_trylock(pthread_mutex_t* mutex);
LibC: Add dummy pthread.h for GCC build.
2019-04-27 22:19:18 +03:00
int pthread_mutex_unlock(pthread_mutex_t*);
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
int pthread_mutex_init(pthread_mutex_t*, pthread_mutexattr_t const*);
LibC: Add dummy pthread.h for GCC build.
2019-04-27 22:19:18 +03:00
int pthread_mutex_destroy(pthread_mutex_t*);
Kernel+LibPthread: pthread_create handles pthread_attr_t Add an initial implementation of pthread attributes for: * detach state (joinable, detached) * schedule params (just priority) * guard page size (as skeleton) (requires kernel support maybe?) * stack size and user-provided stack location (4 or 8 MB only, must be aligned) Add some tests too, to the thread test program. Also, LibC: Move pthread declarations to sys/types.h, where they belong.
2019-11-18 06:08:10 +03:00
LibC: Add dummy pthread.h for GCC build.
2019-04-27 22:19:18 +03:00
int pthread_attr_init(pthread_attr_t*);
int pthread_attr_destroy(pthread_attr_t*);
Kernel+LibPthread: pthread_create handles pthread_attr_t Add an initial implementation of pthread attributes for: * detach state (joinable, detached) * schedule params (just priority) * guard page size (as skeleton) (requires kernel support maybe?) * stack size and user-provided stack location (4 or 8 MB only, must be aligned) Add some tests too, to the thread test program. Also, LibC: Move pthread declarations to sys/types.h, where they belong.
2019-11-18 06:08:10 +03:00
#define PTHREAD_CREATE_JOINABLE 0
#define PTHREAD_CREATE_DETACHED 1
LibC: Implement `pthread_cancel`
2022-06-12 15:48:28 +03:00
#define PTHREAD_CANCELED ((void*)-1)
LibPthread: Add PTHREAD_CANCELED This is just the expected return value of pthread_join() when it fails.
2022-02-11 16:03:11 +03:00
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
int pthread_attr_getdetachstate(pthread_attr_t const*, int*);
Kernel+LibPthread: pthread_create handles pthread_attr_t Add an initial implementation of pthread attributes for: * detach state (joinable, detached) * schedule params (just priority) * guard page size (as skeleton) (requires kernel support maybe?) * stack size and user-provided stack location (4 or 8 MB only, must be aligned) Add some tests too, to the thread test program. Also, LibC: Move pthread declarations to sys/types.h, where they belong.
2019-11-18 06:08:10 +03:00
int pthread_attr_setdetachstate(pthread_attr_t*, int);
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
int pthread_attr_getguardsize(pthread_attr_t const*, size_t*);
Kernel+LibPthread: pthread_create handles pthread_attr_t Add an initial implementation of pthread attributes for: * detach state (joinable, detached) * schedule params (just priority) * guard page size (as skeleton) (requires kernel support maybe?) * stack size and user-provided stack location (4 or 8 MB only, must be aligned) Add some tests too, to the thread test program. Also, LibC: Move pthread declarations to sys/types.h, where they belong.
2019-11-18 06:08:10 +03:00
int pthread_attr_setguardsize(pthread_attr_t*, size_t);
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
int pthread_attr_getschedparam(pthread_attr_t const*, struct sched_param*);
Kernel+LibPthread: pthread_create handles pthread_attr_t Add an initial implementation of pthread attributes for: * detach state (joinable, detached) * schedule params (just priority) * guard page size (as skeleton) (requires kernel support maybe?) * stack size and user-provided stack location (4 or 8 MB only, must be aligned) Add some tests too, to the thread test program. Also, LibC: Move pthread declarations to sys/types.h, where they belong.
2019-11-18 06:08:10 +03:00
int pthread_attr_setschedparam(pthread_attr_t*, const struct sched_param*);
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
int pthread_attr_getstack(pthread_attr_t const*, void**, size_t*);
Kernel+LibPthread: pthread_create handles pthread_attr_t Add an initial implementation of pthread attributes for: * detach state (joinable, detached) * schedule params (just priority) * guard page size (as skeleton) (requires kernel support maybe?) * stack size and user-provided stack location (4 or 8 MB only, must be aligned) Add some tests too, to the thread test program. Also, LibC: Move pthread declarations to sys/types.h, where they belong.
2019-11-18 06:08:10 +03:00
int pthread_attr_setstack(pthread_attr_t* attr, void*, size_t);
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
int pthread_attr_getstacksize(pthread_attr_t const*, size_t*);
Kernel+LibPthread: pthread_create handles pthread_attr_t Add an initial implementation of pthread attributes for: * detach state (joinable, detached) * schedule params (just priority) * guard page size (as skeleton) (requires kernel support maybe?) * stack size and user-provided stack location (4 or 8 MB only, must be aligned) Add some tests too, to the thread test program. Also, LibC: Move pthread declarations to sys/types.h, where they belong.
2019-11-18 06:08:10 +03:00
int pthread_attr_setstacksize(pthread_attr_t*, size_t);
LibPthread: Add non functional pthread_attr_[set|get]scope stubs Standard: https://pubs.opengroup.org/onlinepubs/009695399/functions/pthread_attr_getscope.html Needed for https://fio.readthedocs.io
2021-04-21 12:13:39 +03:00
#define PTHREAD_SCOPE_SYSTEM 0
#define PTHREAD_SCOPE_PROCESS 1
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
int pthread_attr_getscope(pthread_attr_t const*, int*);
LibPthread: Add non functional pthread_attr_[set|get]scope stubs Standard: https://pubs.opengroup.org/onlinepubs/009695399/functions/pthread_attr_getscope.html Needed for https://fio.readthedocs.io
2021-04-21 12:13:39 +03:00
int pthread_attr_setscope(pthread_attr_t*, int);
Everywhere: void arguments to C functions Problem: - C functions with no arguments require a single `void` in the argument list. Solution: - Put the `void` in the argument list of functions in C header files.
2020-12-24 18:41:54 +03:00
int pthread_once(pthread_once_t*, void (*)(void));
LibC: Add dummy pthread.h for GCC build.
2019-04-27 22:19:18 +03:00
#define PTHREAD_ONCE_INIT 0
Add clang-format file Also run it across the whole tree to get everything using the One True Style. We don't yet run this in an automated fashion as it's a little slow, but there is a snippet to do so in makeall.sh.
2019-05-28 12:53:16 +03:00
void* pthread_getspecific(pthread_key_t key);
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
int pthread_setspecific(pthread_key_t key, void const* value);
LibC: Add dummy pthread.h for GCC build.
2019-04-27 22:19:18 +03:00
LibPthread: Add stubs for pthread_{get,set}schedparam() These should be the last thing needed to make SDL build with threads support. I think we can survive just fine with stubs of these for now, especially given that the kernel doesn't care super much about thread priorities anyway.
2019-12-07 17:32:48 +03:00
int pthread_getschedparam(pthread_t thread, int* policy, struct sched_param* param);
int pthread_setschedparam(pthread_t thread, int policy, const struct sched_param* param);
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:04:18 +03:00
#define PTHREAD_MUTEX_NORMAL __PTHREAD_MUTEX_NORMAL
#define PTHREAD_MUTEX_RECURSIVE __PTHREAD_MUTEX_RECURSIVE
LibPthread+LibC: Support PTHREAD_MUTEX_RECURSIVE This allows SDL to build against our native recursive mutex instead of providing its own. Also it's just a nice feature to have. :^)
2019-12-22 16:21:59 +03:00
#define PTHREAD_MUTEX_DEFAULT PTHREAD_MUTEX_NORMAL
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:04:18 +03:00
#define PTHREAD_MUTEX_INITIALIZER __PTHREAD_MUTEX_INITIALIZER
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 23:53:31 +03:00
#define PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP __PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
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:04:18 +03:00
LibPthread: Add stubs for pthread_spin_* functions The stress-ng port depends on these now that it detects we have thread support.
2021-04-19 16:48:47 +03:00
#define PTHREAD_PROCESS_PRIVATE 1
#define PTHREAD_PROCESS_SHARED 2
Kernel: Improve time keeping and dramatically reduce interrupt load This implements a number of changes related to time: * If a HPET is present, it is now used only as a system timer, unless the Local APIC timer is used (in which case the HPET timer will not trigger any interrupts at all). * If a HPET is present, the current time can now be as accurate as the chip can be, independently from the system timer. We now query the HPET main counter for the current time in CPU #0's system timer interrupt, and use that as a base line. If a high precision time is queried, that base line is used in combination with quering the HPET timer directly, which should give a much more accurate time stamp at the expense of more overhead. For faster time stamps, the more coarse value based on the last interrupt will be returned. This also means that any missed interrupts should not cause the time to drift. * The default system interrupt rate is reduced to about 250 per second. * Fix calculation of Thread CPU usage by using the amount of ticks they used rather than the number of times a context switch happened. * Implement CLOCK_REALTIME_COARSE and CLOCK_MONOTONIC_COARSE and use it for most cases where precise timestamps are not needed.
2020-12-04 08:12:50 +03:00
#define PTHREAD_COND_INITIALIZER \
{ \
0, 0, CLOCK_MONOTONIC_COARSE \
Meta+LibHTTP through LibWeb: Make clang-format-10 clean
2020-09-18 10:49:51 +03:00
}
LibC: Add dummy pthread.h for GCC build.
2019-04-27 22:19:18 +03:00
LibC+LibPthread: Stub out pthread_rwlock_* functions
2021-02-13 11:36:05 +03:00
// FIXME: Actually implement this!
#define PTHREAD_RWLOCK_INITIALIZER \
NULL
LibPthread: Implement destruction of pthread_keys Add a function to destroy any keys that were set on the current thread using the algorithm from Dr. POSIX's pthread_key_create. Add some defines to pthread.h for pthread key use, and implement pthread_key_delete. It has a prototype in pthread.h, but any program trying to actually use it would be in for a link-time surprise. Currently, keys are destroyed either via global destructors, with the s_key_destroyer object, or in exit_thread. exit_thread is invoked by pthread_exit, and transitively by pthread_create, via the pthread_create_helper that ensures all threads created with the pthread API properly clean up for themselves when they exit gracefully. A future patch might make s_key_destroyer a C++11 thread_local instead, assuming we get thread_local and thread_local destructors working.
2021-01-01 06:50:59 +03:00
#define PTHREAD_KEYS_MAX 64
#define PTHREAD_DESTRUCTOR_ITERATIONS 4
Add clang-format file Also run it across the whole tree to get everything using the One True Style. We don't yet run this in an automated fashion as it's a little slow, but there is a snippet to do so in makeall.sh.
2019-05-28 12:53:16 +03:00
int pthread_key_create(pthread_key_t* key, void (*destructor)(void*));
LibC: Add dummy pthread.h for GCC build.
2019-04-27 22:19:18 +03:00
int pthread_key_delete(pthread_key_t key);
Add clang-format file Also run it across the whole tree to get everything using the One True Style. We don't yet run this in an automated fashion as it's a little slow, but there is a snippet to do so in makeall.sh.
2019-05-28 12:53:16 +03:00
int pthread_cond_broadcast(pthread_cond_t*);
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
int pthread_cond_init(pthread_cond_t*, pthread_condattr_t const*);
Add clang-format file Also run it across the whole tree to get everything using the One True Style. We don't yet run this in an automated fashion as it's a little slow, but there is a snippet to do so in makeall.sh.
2019-05-28 12:53:16 +03:00
int pthread_cond_signal(pthread_cond_t*);
int pthread_cond_wait(pthread_cond_t*, pthread_mutex_t*);
LibPthread: Implement condition variables This feels like a pretty naive implementation, but I think it can work. Basically each waiter creates an object on its stack that is then added to a linked list inside by the pthread_cond_t. Signalling is then done by walking the list and unsetting the "waiting" flag on as many of the waiters as you like.
2019-12-07 16:24:09 +03:00
int pthread_condattr_init(pthread_condattr_t*);
LibPthread: Implement pthread_condattr_getclock I noticed this was missing while adding spec comments a bit ago. It's small and easy enough to implement, might as well make us more POSIX compliant.
2022-01-09 06:56:52 +03:00
int pthread_condattr_getclock(pthread_condattr_t* attr, clockid_t* clock);
LibPthread: Implement condition variables This feels like a pretty naive implementation, but I think it can work. Basically each waiter creates an object on its stack that is then added to a linked list inside by the pthread_cond_t. Signalling is then done by walking the list and unsetting the "waiting" flag on as many of the waiters as you like.
2019-12-07 16:24:09 +03:00
int pthread_condattr_setclock(pthread_condattr_t*, clockid_t);
Add clang-format file Also run it across the whole tree to get everything using the One True Style. We don't yet run this in an automated fashion as it's a little slow, but there is a snippet to do so in makeall.sh.
2019-05-28 12:53:16 +03:00
int pthread_condattr_destroy(pthread_condattr_t*);
int pthread_cond_destroy(pthread_cond_t*);
int pthread_cond_timedwait(pthread_cond_t*, pthread_mutex_t*, const struct timespec*);
LibC: Add dummy pthread.h for GCC build.
2019-04-27 22:19:18 +03:00
LibPthread: Stub pthread_setcancelstate() and pthread_setcanceltype()
2021-01-12 15:40:48 +03:00
#define PTHREAD_CANCEL_ENABLE 1
#define PTHREAD_CANCEL_DISABLE 2
LibC: Partially implement pthread_setcancel{state,type}() With those partially implemented I can start to clone the SerenityOS git repository via HTTPS. The download still fails half-way through because SSL_read returns an error for reasons I haven't investigated yet.
2021-05-10 16:13:59 +03:00
#define PTHREAD_CANCEL_DEFERRED 1
#define PTHREAD_CANCEL_ASYNCHRONOUS 2
LibPthread: Stub pthread_setcancelstate() and pthread_setcanceltype()
2021-01-12 15:40:48 +03:00
int pthread_cancel(pthread_t);
int pthread_setcancelstate(int state, int* oldstate);
int pthread_setcanceltype(int type, int* oldtype);
Everywhere: void arguments to C functions Problem: - C functions with no arguments require a single `void` in the argument list. Solution: - Put the `void` in the argument list of functions in C header files.
2020-12-24 18:41:54 +03:00
void pthread_testcancel(void);
LibC: Add dummy pthread.h for GCC build.
2019-04-27 22:19:18 +03:00
Add clang-format file Also run it across the whole tree to get everything using the One True Style. We don't yet run this in an automated fashion as it's a little slow, but there is a snippet to do so in makeall.sh.
2019-05-28 12:53:16 +03:00
int pthread_spin_destroy(pthread_spinlock_t*);
int pthread_spin_init(pthread_spinlock_t*, int);
int pthread_spin_lock(pthread_spinlock_t*);
int pthread_spin_trylock(pthread_spinlock_t*);
int pthread_spin_unlock(pthread_spinlock_t*);
Everywhere: void arguments to C functions Problem: - C functions with no arguments require a single `void` in the argument list. Solution: - Put the `void` in the argument list of functions in C header files.
2020-12-24 18:41:54 +03:00
pthread_t pthread_self(void);
LibC: Add dummy pthread.h for GCC build.
2019-04-27 22:19:18 +03:00
int pthread_detach(pthread_t);
int pthread_equal(pthread_t, pthread_t);
Add clang-format file Also run it across the whole tree to get everything using the One True Style. We don't yet run this in an automated fashion as it's a little slow, but there is a snippet to do so in makeall.sh.
2019-05-28 12:53:16 +03:00
int pthread_mutexattr_init(pthread_mutexattr_t*);
int pthread_mutexattr_settype(pthread_mutexattr_t*, int);
LibPthread: Add implementation for pthread_mutexattr_gettype
2021-05-08 05:49:36 +03:00
int pthread_mutexattr_gettype(pthread_mutexattr_t*, int*);
Add clang-format file Also run it across the whole tree to get everything using the One True Style. We don't yet run this in an automated fashion as it's a little slow, but there is a snippet to do so in makeall.sh.
2019-05-28 12:53:16 +03:00
int pthread_mutexattr_destroy(pthread_mutexattr_t*);
LibC: Add dummy pthread.h for GCC build.
2019-04-27 22:19:18 +03:00
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
int pthread_setname_np(pthread_t, char const*);
LibPthread: Fix incompatible pthread_setname_np(), pthread_getname_np() Other implementations of pthread_setname_np() do not take the name length as an argument. For pthread_getname_np(), other implementations take the buffer size as a size_t. This patch brings us in line with other implementations.
2020-01-11 14:54:30 +03:00
int pthread_getname_np(pthread_t, char*, size_t);
LibPThread: Add pthread_set/getname_np These wrappers call the set_thread_name and get_thread_name syscalls respectively.
2019-12-07 22:47:46 +03:00
LibPthread: Add pthread_equal()
2021-01-12 15:42:45 +03:00
int pthread_equal(pthread_t t1, pthread_t t2);
LibC+LibPthread: Stub out pthread_rwlock_* functions
2021-02-13 11:36:05 +03:00
int pthread_rwlock_destroy(pthread_rwlock_t*);
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
int pthread_rwlock_init(pthread_rwlock_t* __restrict, pthread_rwlockattr_t const* __restrict);
LibC+LibPthread: Stub out pthread_rwlock_* functions
2021-02-13 11:36:05 +03:00
int pthread_rwlock_rdlock(pthread_rwlock_t*);
int pthread_rwlock_timedrdlock(pthread_rwlock_t* __restrict, const struct timespec* __restrict);
int pthread_rwlock_timedwrlock(pthread_rwlock_t* __restrict, const struct timespec* __restrict);
int pthread_rwlock_tryrdlock(pthread_rwlock_t*);
int pthread_rwlock_trywrlock(pthread_rwlock_t*);
int pthread_rwlock_unlock(pthread_rwlock_t*);
int pthread_rwlock_wrlock(pthread_rwlock_t*);
int pthread_rwlockattr_destroy(pthread_rwlockattr_t*);
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
int pthread_rwlockattr_getpshared(pthread_rwlockattr_t const* __restrict, int* __restrict);
LibC+LibPthread: Stub out pthread_rwlock_* functions
2021-02-13 11:36:05 +03:00
int pthread_rwlockattr_init(pthread_rwlockattr_t*);
int pthread_rwlockattr_setpshared(pthread_rwlockattr_t*, int);
LibPthread: Stub out `pthread_atfork()`
2021-02-13 14:08:54 +03:00
int pthread_atfork(void (*prepare)(void), void (*parent)(void), void (*child)(void));
LibC: Add dummy pthread.h for GCC build.
2019-04-27 22:19:18 +03:00
__END_DECLS
Reference in New Issue Copy Permalink