RepoMirrors
/
musl
mirror of git://git.musl-libc.org/musl
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
musl/include/pthread.h

241 lines
9.1 KiB
C
Raw Normal View History

initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
#ifndef _PTHREAD_H
#define _PTHREAD_H
#ifdef __cplusplus
extern "C" {
#endif
remove all remaining redundant __restrict/__inline/_Noreturn defs
2012-09-08 21:14:52 +00:00
#include <features.h>
further use of _Noreturn, for non-plain-C functions note that POSIX does not specify these functions as _Noreturn, because POSIX is aligned with C99, not the new C11 standard. when POSIX is eventually updated to C11, it will almost surely give these functions the _Noreturn attribute. for now, the actual _Noreturn keyword is not used anyway when compiling with a c99 compiler, which is what POSIX requires; the GCC __attribute__ is used instead if it's available, however. in a few places, I've added infinite for loops at the end of _Noreturn functions to silence compiler warnings. presumably __buildin_unreachable could achieve the same thing, but it would only work on newer GCCs and would not be portable. the loops should have near-zero code size cost anyway. like the previous _Noreturn commit, this one is based on patches contributed by philomath.
2012-09-07 03:34:10 +00:00
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
#define __NEED_time_t
pthread.h needs clockid_t actually it gets this from time.h if _POSIX_C_SOURCE or any other feature test macros are defined, but it breaks if they're not.
2011-03-13 02:54:19 +00:00
#define __NEED_clockid_t
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
#define __NEED_struct_timespec
#define __NEED_sigset_t
#define __NEED_pthread_t
reorganize pthread data structures and move the definitions to alltypes.h this allows sys/types.h to provide the pthread types, as required by POSIX. this design also facilitates forcing ABI-compatible sizes in the arch-specific alltypes.h, while eliminating the need for developers changing the internals of the pthread types to poke around with arch-specific headers they may not be able to test.
2011-02-17 22:16:20 +00:00
#define __NEED_pthread_attr_t
#define __NEED_pthread_mutexattr_t
#define __NEED_pthread_condattr_t
#define __NEED_pthread_rwlockattr_t
#define __NEED_pthread_barrierattr_t
#define __NEED_pthread_mutex_t
#define __NEED_pthread_cond_t
#define __NEED_pthread_rwlock_t
#define __NEED_pthread_barrier_t
#define __NEED_pthread_spinlock_t
#define __NEED_pthread_key_t
#define __NEED_pthread_once_t
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
#define __NEED_size_t
#include <bits/alltypes.h>
add to pthread.h: pthread_mutex_timedlock and sched.h, time.h
2011-02-17 02:21:26 +00:00
#include <sched.h>
#include <time.h>
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
#define PTHREAD_CREATE_JOINABLE 0
#define PTHREAD_CREATE_DETACHED 1
#define PTHREAD_MUTEX_NORMAL 0
#define PTHREAD_MUTEX_DEFAULT 0
#define PTHREAD_MUTEX_RECURSIVE 1
#define PTHREAD_MUTEX_ERRORCHECK 2
#define PTHREAD_MUTEX_STALLED 0
#define PTHREAD_MUTEX_ROBUST 1
#define PTHREAD_PRIO_NONE 0
#define PTHREAD_PRIO_INHERIT 1
#define PTHREAD_PRIO_PROTECT 2
#define PTHREAD_INHERIT_SCHED 0
#define PTHREAD_EXPLICIT_SCHED 1
#define PTHREAD_SCOPE_SYSTEM 0
#define PTHREAD_SCOPE_PROCESS 1
#define PTHREAD_PROCESS_PRIVATE 0
#define PTHREAD_PROCESS_SHARED 1
use c++-friendly initializers for pthread initializer definitions these will also avoid obnoxious warnings with gcc -Wbraces.
2012-03-01 03:55:08 +00:00
#define PTHREAD_MUTEX_INITIALIZER {{{0}}}
#define PTHREAD_RWLOCK_INITIALIZER {{{0}}}
#define PTHREAD_COND_INITIALIZER {{{0}}}
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
#define PTHREAD_ONCE_INIT 0
#define PTHREAD_CANCEL_ENABLE 0
#define PTHREAD_CANCEL_DISABLE 1
add new masked cancellation mode this is a new extension which is presently intended only for experimental and internal libc use. interface and behavior details may change subject to feedback and experience from using it internally. the basic concept for the new PTHREAD_CANCEL_MASKED state is that the first cancellation point to observe the cancellation request fails with an errno value of ECANCELED rather than acting on cancellation, allowing the caller to process the status and choose whether/how to act upon it.
2015-02-22 03:05:15 +00:00
#define PTHREAD_CANCEL_MASKED 2
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
#define PTHREAD_CANCEL_DEFERRED 0
#define PTHREAD_CANCEL_ASYNCHRONOUS 1
fix misspelled PTHREAD_CANCELED constant
2011-04-02 00:48:02 +00:00
#define PTHREAD_CANCELED ((void *)-1)
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
#define PTHREAD_BARRIER_SERIAL_THREAD (-1)
use restrict everywhere it's required by c99 and/or posix 2008 to deal with the fact that the public headers may be used with pre-c99 compilers, __restrict is used in place of restrict, and defined appropriately for any supported compiler. we also avoid the form [restrict] since older versions of gcc rejected it due to a bug in the original c99 standard, and instead use the form *restrict.
2012-09-07 02:44:55 +00:00
int pthread_create(pthread_t *__restrict, const pthread_attr_t *__restrict, void *(*)(void *), void *__restrict);
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
int pthread_detach(pthread_t);
further use of _Noreturn, for non-plain-C functions note that POSIX does not specify these functions as _Noreturn, because POSIX is aligned with C99, not the new C11 standard. when POSIX is eventually updated to C11, it will almost surely give these functions the _Noreturn attribute. for now, the actual _Noreturn keyword is not used anyway when compiling with a c99 compiler, which is what POSIX requires; the GCC __attribute__ is used instead if it's available, however. in a few places, I've added infinite for loops at the end of _Noreturn functions to silence compiler warnings. presumably __buildin_unreachable could achieve the same thing, but it would only work on newer GCCs and would not be portable. the loops should have near-zero code size cost anyway. like the previous _Noreturn commit, this one is based on patches contributed by philomath.
2012-09-07 03:34:10 +00:00
_Noreturn void pthread_exit(void *);
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
int pthread_join(pthread_t, void **);
restore attribute((const)) to pthread_self and errno location decls revert commit a603a75a72bb469c6be4963ed1b55fabe675fe15. as a result of commit 1c84c99913bf1cd47b866ed31e665848a0da84a2 this is now safe, assuming an interpretation of the somewhat-underspecified attribute((const)) consistent with real-world usage.
2018-10-16 17:48:10 +00:00
#ifdef __GNUC__
__attribute__((const))
#endif
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
pthread_t pthread_self(void);
macro for pthread_equal no sense bloating apps with a function call for an equality comparison...
2011-08-14 19:17:36 +00:00
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
int pthread_equal(pthread_t, pthread_t);
don't shadow functions with macros in C++ C++ programmers typically expect something like "::function(x,y)" to work and may be surprised to find that "(::function)(x,y)" is actually required due to the headers declaring a macro version of some standard functions. We already omit function-like macros for C++ in most cases where there is a real function available. This commit extends this to the remaining function-like macros which have a real function version.
2014-12-09 02:18:12 +00:00
#ifndef __cplusplus
macro for pthread_equal no sense bloating apps with a function call for an equality comparison...
2011-08-14 19:17:36 +00:00
#define pthread_equal(x,y) ((x)==(y))
don't shadow functions with macros in C++ C++ programmers typically expect something like "::function(x,y)" to work and may be surprised to find that "(::function)(x,y)" is actually required due to the headers declaring a macro version of some standard functions. We already omit function-like macros for C++ in most cases where there is a real function available. This commit extends this to the remaining function-like macros which have a real function version.
2014-12-09 02:18:12 +00:00
#endif
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
int pthread_setcancelstate(int, int *);
int pthread_setcanceltype(int, int *);
void pthread_testcancel(void);
int pthread_cancel(pthread_t);
add support for thread scheduling (POSIX TPS option) linux's sched_* syscalls actually implement the TPS (thread scheduling) functionality, not the PS (process scheduling) functionality which the sched_* functions are supposed to have. omitting support for the PS option (and having the sched_* interfaces fail with ENOSYS rather than omitting them, since some broken software assumes they exist) seems to be the only conforming way to do this on linux.
2012-11-11 20:38:04 +00:00
int pthread_getschedparam(pthread_t, int *__restrict, struct sched_param *__restrict);
int pthread_setschedparam(pthread_t, int, const struct sched_param *);
int pthread_setschedprio(pthread_t, int);
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
int pthread_once(pthread_once_t *, void (*)(void));
use restrict everywhere it's required by c99 and/or posix 2008 to deal with the fact that the public headers may be used with pre-c99 compilers, __restrict is used in place of restrict, and defined appropriately for any supported compiler. we also avoid the form [restrict] since older versions of gcc rejected it due to a bug in the original c99 standard, and instead use the form *restrict.
2012-09-07 02:44:55 +00:00
int pthread_mutex_init(pthread_mutex_t *__restrict, const pthread_mutexattr_t *__restrict);
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
int pthread_mutex_lock(pthread_mutex_t *);
int pthread_mutex_unlock(pthread_mutex_t *);
int pthread_mutex_trylock(pthread_mutex_t *);
use restrict everywhere it's required by c99 and/or posix 2008 to deal with the fact that the public headers may be used with pre-c99 compilers, __restrict is used in place of restrict, and defined appropriately for any supported compiler. we also avoid the form [restrict] since older versions of gcc rejected it due to a bug in the original c99 standard, and instead use the form *restrict.
2012-09-07 02:44:55 +00:00
int pthread_mutex_timedlock(pthread_mutex_t *__restrict, const struct timespec *__restrict);
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
int pthread_mutex_destroy(pthread_mutex_t *);
implement robust mutexes some of this code should be cleaned up, e.g. using macros for some of the bit flags, masks, etc. nonetheless, the code is believed to be working and correct at this point.
2011-03-18 00:41:37 +00:00
int pthread_mutex_consistent(pthread_mutex_t *);
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
add stub versions of some missing optional pthread interfaces priority inheritance is not yet supported, and priority protection probably will not be supported ever unless there's serious demand for it (it's a fairly heavy-weight feature). per-thread cpu clocks would be nice to have, but to my knowledge linux is still not capable of supporting them. glibc fakes them by using the _process_ cpu-time clock and subtracting the thread creation time, which gives seriously incorrect semantics (worse than not supporting the feature at all), so until there's a way to do it right, it will remain as a stub that always fails.
2012-11-17 23:42:16 +00:00
int pthread_mutex_getprioceiling(const pthread_mutex_t *__restrict, int *__restrict);
int pthread_mutex_setprioceiling(pthread_mutex_t *__restrict, int, int *__restrict);
use restrict everywhere it's required by c99 and/or posix 2008 to deal with the fact that the public headers may be used with pre-c99 compilers, __restrict is used in place of restrict, and defined appropriately for any supported compiler. we also avoid the form [restrict] since older versions of gcc rejected it due to a bug in the original c99 standard, and instead use the form *restrict.
2012-09-07 02:44:55 +00:00
int pthread_cond_init(pthread_cond_t *__restrict, const pthread_condattr_t *__restrict);
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
int pthread_cond_destroy(pthread_cond_t *);
use restrict everywhere it's required by c99 and/or posix 2008 to deal with the fact that the public headers may be used with pre-c99 compilers, __restrict is used in place of restrict, and defined appropriately for any supported compiler. we also avoid the form [restrict] since older versions of gcc rejected it due to a bug in the original c99 standard, and instead use the form *restrict.
2012-09-07 02:44:55 +00:00
int pthread_cond_wait(pthread_cond_t *__restrict, pthread_mutex_t *__restrict);
int pthread_cond_timedwait(pthread_cond_t *__restrict, pthread_mutex_t *__restrict, const struct timespec *__restrict);
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
int pthread_cond_broadcast(pthread_cond_t *);
int pthread_cond_signal(pthread_cond_t *);
use restrict everywhere it's required by c99 and/or posix 2008 to deal with the fact that the public headers may be used with pre-c99 compilers, __restrict is used in place of restrict, and defined appropriately for any supported compiler. we also avoid the form [restrict] since older versions of gcc rejected it due to a bug in the original c99 standard, and instead use the form *restrict.
2012-09-07 02:44:55 +00:00
int pthread_rwlock_init(pthread_rwlock_t *__restrict, const pthread_rwlockattr_t *__restrict);
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
int pthread_rwlock_destroy(pthread_rwlock_t *);
int pthread_rwlock_rdlock(pthread_rwlock_t *);
int pthread_rwlock_tryrdlock(pthread_rwlock_t *);
use restrict everywhere it's required by c99 and/or posix 2008 to deal with the fact that the public headers may be used with pre-c99 compilers, __restrict is used in place of restrict, and defined appropriately for any supported compiler. we also avoid the form [restrict] since older versions of gcc rejected it due to a bug in the original c99 standard, and instead use the form *restrict.
2012-09-07 02:44:55 +00:00
int pthread_rwlock_timedrdlock(pthread_rwlock_t *__restrict, const struct timespec *__restrict);
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
int pthread_rwlock_wrlock(pthread_rwlock_t *);
int pthread_rwlock_trywrlock(pthread_rwlock_t *);
use restrict everywhere it's required by c99 and/or posix 2008 to deal with the fact that the public headers may be used with pre-c99 compilers, __restrict is used in place of restrict, and defined appropriately for any supported compiler. we also avoid the form [restrict] since older versions of gcc rejected it due to a bug in the original c99 standard, and instead use the form *restrict.
2012-09-07 02:44:55 +00:00
int pthread_rwlock_timedwrlock(pthread_rwlock_t *__restrict, const struct timespec *__restrict);
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
int pthread_rwlock_unlock(pthread_rwlock_t *);
int pthread_spin_init(pthread_spinlock_t *, int);
int pthread_spin_destroy(pthread_spinlock_t *);
int pthread_spin_lock(pthread_spinlock_t *);
int pthread_spin_trylock(pthread_spinlock_t *);
int pthread_spin_unlock(pthread_spinlock_t *);
use restrict everywhere it's required by c99 and/or posix 2008 to deal with the fact that the public headers may be used with pre-c99 compilers, __restrict is used in place of restrict, and defined appropriately for any supported compiler. we also avoid the form [restrict] since older versions of gcc rejected it due to a bug in the original c99 standard, and instead use the form *restrict.
2012-09-07 02:44:55 +00:00
int pthread_barrier_init(pthread_barrier_t *__restrict, const pthread_barrierattr_t *__restrict, unsigned);
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
int pthread_barrier_destroy(pthread_barrier_t *);
int pthread_barrier_wait(pthread_barrier_t *);
int pthread_key_create(pthread_key_t *, void (*)(void *));
int pthread_key_delete(pthread_key_t);
void *pthread_getspecific(pthread_key_t);
int pthread_setspecific(pthread_key_t, const void *);
int pthread_attr_init(pthread_attr_t *);
int pthread_attr_destroy(pthread_attr_t *);
use restrict everywhere it's required by c99 and/or posix 2008 to deal with the fact that the public headers may be used with pre-c99 compilers, __restrict is used in place of restrict, and defined appropriately for any supported compiler. we also avoid the form [restrict] since older versions of gcc rejected it due to a bug in the original c99 standard, and instead use the form *restrict.
2012-09-07 02:44:55 +00:00
int pthread_attr_getguardsize(const pthread_attr_t *__restrict, size_t *__restrict);
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
int pthread_attr_setguardsize(pthread_attr_t *, size_t);
use restrict everywhere it's required by c99 and/or posix 2008 to deal with the fact that the public headers may be used with pre-c99 compilers, __restrict is used in place of restrict, and defined appropriately for any supported compiler. we also avoid the form [restrict] since older versions of gcc rejected it due to a bug in the original c99 standard, and instead use the form *restrict.
2012-09-07 02:44:55 +00:00
int pthread_attr_getstacksize(const pthread_attr_t *__restrict, size_t *__restrict);
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
int pthread_attr_setstacksize(pthread_attr_t *, size_t);
missing const in some pthread_attr_* prototypes
2011-03-11 14:46:31 +00:00
int pthread_attr_getdetachstate(const pthread_attr_t *, int *);
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
int pthread_attr_setdetachstate(pthread_attr_t *, int);
use restrict everywhere it's required by c99 and/or posix 2008 to deal with the fact that the public headers may be used with pre-c99 compilers, __restrict is used in place of restrict, and defined appropriately for any supported compiler. we also avoid the form [restrict] since older versions of gcc rejected it due to a bug in the original c99 standard, and instead use the form *restrict.
2012-09-07 02:44:55 +00:00
int pthread_attr_getstack(const pthread_attr_t *__restrict, void **__restrict, size_t *__restrict);
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
int pthread_attr_setstack(pthread_attr_t *, void *, size_t);
use restrict everywhere it's required by c99 and/or posix 2008 to deal with the fact that the public headers may be used with pre-c99 compilers, __restrict is used in place of restrict, and defined appropriately for any supported compiler. we also avoid the form [restrict] since older versions of gcc rejected it due to a bug in the original c99 standard, and instead use the form *restrict.
2012-09-07 02:44:55 +00:00
int pthread_attr_getscope(const pthread_attr_t *__restrict, int *__restrict);
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
int pthread_attr_setscope(pthread_attr_t *, int);
use restrict everywhere it's required by c99 and/or posix 2008 to deal with the fact that the public headers may be used with pre-c99 compilers, __restrict is used in place of restrict, and defined appropriately for any supported compiler. we also avoid the form [restrict] since older versions of gcc rejected it due to a bug in the original c99 standard, and instead use the form *restrict.
2012-09-07 02:44:55 +00:00
int pthread_attr_getschedpolicy(const pthread_attr_t *__restrict, int *__restrict);
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
int pthread_attr_setschedpolicy(pthread_attr_t *, int);
use restrict everywhere it's required by c99 and/or posix 2008 to deal with the fact that the public headers may be used with pre-c99 compilers, __restrict is used in place of restrict, and defined appropriately for any supported compiler. we also avoid the form [restrict] since older versions of gcc rejected it due to a bug in the original c99 standard, and instead use the form *restrict.
2012-09-07 02:44:55 +00:00
int pthread_attr_getschedparam(const pthread_attr_t *__restrict, struct sched_param *__restrict);
int pthread_attr_setschedparam(pthread_attr_t *__restrict, const struct sched_param *__restrict);
int pthread_attr_getinheritsched(const pthread_attr_t *__restrict, int *__restrict);
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
int pthread_attr_setinheritsched(pthread_attr_t *, int);
int pthread_mutexattr_destroy(pthread_mutexattr_t *);
use restrict everywhere it's required by c99 and/or posix 2008 to deal with the fact that the public headers may be used with pre-c99 compilers, __restrict is used in place of restrict, and defined appropriately for any supported compiler. we also avoid the form [restrict] since older versions of gcc rejected it due to a bug in the original c99 standard, and instead use the form *restrict.
2012-09-07 02:44:55 +00:00
int pthread_mutexattr_getprioceiling(const pthread_mutexattr_t *__restrict, int *__restrict);
int pthread_mutexattr_getprotocol(const pthread_mutexattr_t *__restrict, int *__restrict);
int pthread_mutexattr_getpshared(const pthread_mutexattr_t *__restrict, int *__restrict);
int pthread_mutexattr_getrobust(const pthread_mutexattr_t *__restrict, int *__restrict);
int pthread_mutexattr_gettype(const pthread_mutexattr_t *__restrict, int *__restrict);
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
int pthread_mutexattr_init(pthread_mutexattr_t *);
int pthread_mutexattr_setprioceiling(pthread_mutexattr_t *, int);
int pthread_mutexattr_setprotocol(pthread_mutexattr_t *, int);
int pthread_mutexattr_setpshared(pthread_mutexattr_t *, int);
int pthread_mutexattr_setrobust(pthread_mutexattr_t *, int);
int pthread_mutexattr_settype(pthread_mutexattr_t *, int);
add prototypes for pthread_condattr_* and pthread_rwlockattr_*
2011-03-07 21:45:48 +00:00
int pthread_condattr_init(pthread_condattr_t *);
int pthread_condattr_destroy(pthread_condattr_t *);
int pthread_condattr_setclock(pthread_condattr_t *, clockid_t);
int pthread_condattr_setpshared(pthread_condattr_t *, int);
use restrict everywhere it's required by c99 and/or posix 2008 to deal with the fact that the public headers may be used with pre-c99 compilers, __restrict is used in place of restrict, and defined appropriately for any supported compiler. we also avoid the form [restrict] since older versions of gcc rejected it due to a bug in the original c99 standard, and instead use the form *restrict.
2012-09-07 02:44:55 +00:00
int pthread_condattr_getclock(const pthread_condattr_t *__restrict, clockid_t *__restrict);
int pthread_condattr_getpshared(const pthread_condattr_t *__restrict, int *__restrict);
add prototypes for pthread_condattr_* and pthread_rwlockattr_*
2011-03-07 21:45:48 +00:00
int pthread_rwlockattr_init(pthread_rwlockattr_t *);
int pthread_rwlockattr_destroy(pthread_rwlockattr_t *);
int pthread_rwlockattr_setpshared(pthread_rwlockattr_t *, int);
use restrict everywhere it's required by c99 and/or posix 2008 to deal with the fact that the public headers may be used with pre-c99 compilers, __restrict is used in place of restrict, and defined appropriately for any supported compiler. we also avoid the form [restrict] since older versions of gcc rejected it due to a bug in the original c99 standard, and instead use the form *restrict.
2012-09-07 02:44:55 +00:00
int pthread_rwlockattr_getpshared(const pthread_rwlockattr_t *__restrict, int *__restrict);
add prototypes for pthread_condattr_* and pthread_rwlockattr_*
2011-03-07 21:45:48 +00:00
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
int pthread_barrierattr_destroy(pthread_barrierattr_t *);
use restrict everywhere it's required by c99 and/or posix 2008 to deal with the fact that the public headers may be used with pre-c99 compilers, __restrict is used in place of restrict, and defined appropriately for any supported compiler. we also avoid the form [restrict] since older versions of gcc rejected it due to a bug in the original c99 standard, and instead use the form *restrict.
2012-09-07 02:44:55 +00:00
int pthread_barrierattr_getpshared(const pthread_barrierattr_t *__restrict, int *__restrict);
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
int pthread_barrierattr_init(pthread_barrierattr_t *);
int pthread_barrierattr_setpshared(pthread_barrierattr_t *, int);
add pthread_atfork interface note that this presently does not handle consistency of the libc's own global state during forking. as per POSIX 2008, if the parent process was threaded, the child process may only call async-signal-safe functions until one of the exec-family functions is called, so the current behavior is believed to be conformant even if non-ideal. it may be improved at some later time.
2011-02-19 00:52:42 +00:00
int pthread_atfork(void (*)(void), void (*)(void), void (*)(void));
implement pthread_[sg]etconcurrency. there is a resource limit of 0 bits to store the concurrency level requested. thus any positive level exceeds a resource limit, resulting in EAGAIN. :-)
2011-05-30 15:31:07 +00:00
int pthread_getconcurrency(void);
int pthread_setconcurrency(int);
add stub versions of some missing optional pthread interfaces priority inheritance is not yet supported, and priority protection probably will not be supported ever unless there's serious demand for it (it's a fairly heavy-weight feature). per-thread cpu clocks would be nice to have, but to my knowledge linux is still not capable of supporting them. glibc fakes them by using the _process_ cpu-time clock and subtracting the thread creation time, which gives seriously incorrect semantics (worse than not supporting the feature at all), so until there's a way to do it right, it will remain as a stub that always fails.
2012-11-17 23:42:16 +00:00
int pthread_getcpuclockid(pthread_t, clockid_t *);
replace bad cancellation cleanup abi with a sane one the old abi was intended to duplicate glibc's abi at the expense of being ugly and slow, but it turns out glib was not even using that abi except on non-gcc-compatible compilers (which it doesn't even support) and was instead using an exceptions-in-c/unwind-based approach whose abi we could not duplicate anyway without nasty dwarf2/unwind integration. the new abi is copied from a very old glibc abi, which seems to still be supported/present in current glibc. it avoids all unwinding, whether by sjlj or exceptions, and merely maintains a linked list of cleanup functions to be called from the context of pthread_exit. i've made some care to ensure that longjmp out of a cleanup function should work, even though it is not required to. this change breaks abi compatibility with programs which were using pthread cancellation, which is unfortunate, but that's why i'm making the change now rather than later. considering that most pthread features have not been usable until recently anyway, i don't see it as a major issue at this point.
2012-02-09 07:33:08 +00:00
struct __ptcb {
void (*__f)(void *);
void *__x;
struct __ptcb *__next;
};
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
replace bad cancellation cleanup abi with a sane one the old abi was intended to duplicate glibc's abi at the expense of being ugly and slow, but it turns out glib was not even using that abi except on non-gcc-compatible compilers (which it doesn't even support) and was instead using an exceptions-in-c/unwind-based approach whose abi we could not duplicate anyway without nasty dwarf2/unwind integration. the new abi is copied from a very old glibc abi, which seems to still be supported/present in current glibc. it avoids all unwinding, whether by sjlj or exceptions, and merely maintains a linked list of cleanup functions to be called from the context of pthread_exit. i've made some care to ensure that longjmp out of a cleanup function should work, even though it is not required to. this change breaks abi compatibility with programs which were using pthread cancellation, which is unfortunate, but that's why i'm making the change now rather than later. considering that most pthread features have not been usable until recently anyway, i don't see it as a major issue at this point.
2012-02-09 07:33:08 +00:00
void _pthread_cleanup_push(struct __ptcb *, void (*)(void *), void *);
void _pthread_cleanup_pop(struct __ptcb *, int);
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
replace bad cancellation cleanup abi with a sane one the old abi was intended to duplicate glibc's abi at the expense of being ugly and slow, but it turns out glib was not even using that abi except on non-gcc-compatible compilers (which it doesn't even support) and was instead using an exceptions-in-c/unwind-based approach whose abi we could not duplicate anyway without nasty dwarf2/unwind integration. the new abi is copied from a very old glibc abi, which seems to still be supported/present in current glibc. it avoids all unwinding, whether by sjlj or exceptions, and merely maintains a linked list of cleanup functions to be called from the context of pthread_exit. i've made some care to ensure that longjmp out of a cleanup function should work, even though it is not required to. this change breaks abi compatibility with programs which were using pthread cancellation, which is unfortunate, but that's why i'm making the change now rather than later. considering that most pthread features have not been usable until recently anyway, i don't see it as a major issue at this point.
2012-02-09 07:33:08 +00:00
#define pthread_cleanup_push(f, x) do { struct __ptcb __cb; _pthread_cleanup_push(&__cb, f, x);
#define pthread_cleanup_pop(r) _pthread_cleanup_pop(&__cb, (r)); } while(0)
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
provide prototype for pthread_getattr_np
2013-04-01 03:27:57 +00:00
#ifdef _GNU_SOURCE
add pthread_setaffinity_np and pthread_getaffinity_np functions
2013-08-11 01:41:05 +00:00
struct cpu_set_t;
int pthread_getaffinity_np(pthread_t, size_t, struct cpu_set_t *);
int pthread_setaffinity_np(pthread_t, size_t, const struct cpu_set_t *);
provide prototype for pthread_getattr_np
2013-04-01 03:27:57 +00:00
int pthread_getattr_np(pthread_t, pthread_attr_t *);
add pthread_setname_np the thread name is displayed by gdb's "info threads".
2016-09-17 00:54:00 +00:00
int pthread_setname_np(pthread_t, const char *);
add limited pthread_setattr_default_np API to set stack size defaults based on patch by Timo Teräs: While generally this is a bad API, it is the only existing API to affect c++ (std::thread) and c11 (thrd_create) thread stack size. This patch allows applications only to increate stack and guard page sizes.
2016-11-08 17:09:05 +00:00
int pthread_getattr_default_np(pthread_attr_t *);
int pthread_setattr_default_np(const pthread_attr_t *);
pthread: implement try/timed join variants
2016-05-07 18:48:21 +00:00
int pthread_tryjoin_np(pthread_t, void **);
int pthread_timedjoin_np(pthread_t, void **, const struct timespec *);
provide prototype for pthread_getattr_np
2013-04-01 03:27:57 +00:00
#endif
add time64 symbol name redirects to public headers, under arch control a _REDIR_TIME64 macro is introduced, which the arch's alltypes.h is expected to define, to control redirection of symbol names for interfaces that involve time_t and derived types. this ensures that object files will only be linked to libc interfaces matching the ABI whose headers they were compiled against. along with time32 compat shims, which will be introduced separately, the redirection also makes it possible for a single libc (static or shared) to be used with object files produced with either the old (32-bit time_t) headers or the new ones after 64-bit time_t switchover takes place. mixing of such object files (or shared libraries) in the same program will also be possible, but must be done with care; ABI between libc and a consumer of the libc interfaces is guaranteed to match by the the symbol name redirection, but pairwise ABI between consumers of libc that define interfaces between each other in terms of time_t is not guaranteed to match. this change adds a dependency on an additional "GNU C" feature to the public headers for existing 32-bit archs, which is generally undesirable; however, the feature is one which glibc has depended on for a long time, and thus which any viable alternative compiler is going to need to provide. 64-bit archs are not affected, nor will future 32-bit archs be, regardless of whether they are "new" on the kernel side (e.g. riscv32) or just newly-added (e.g. a new sparc or xtensa port). the same applies to newly-added ABIs for existing machine-level archs.
2019-07-31 19:24:58 +00:00
#if _REDIR_TIME64
__REDIR(pthread_mutex_timedlock, __pthread_mutex_timedlock_time64);
__REDIR(pthread_cond_timedwait, __pthread_cond_timedwait_time64);
__REDIR(pthread_rwlock_timedrdlock, __pthread_rwlock_timedrdlock_time64);
__REDIR(pthread_rwlock_timedwrlock, __pthread_rwlock_timedwrlock_time64);
#ifdef _GNU_SOURCE
__REDIR(pthread_timedjoin_np, __pthread_timedjoin_np_time64);
#endif
#endif
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
#ifdef __cplusplus
}
#endif
#endif