aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--main/musl/0002-d86af2a0-to-4992ace9.patch1083
-rw-r--r--main/musl/APKBUILD6
2 files changed, 1088 insertions, 1 deletions
diff --git a/main/musl/0002-d86af2a0-to-4992ace9.patch b/main/musl/0002-d86af2a0-to-4992ace9.patch
new file mode 100644
index 0000000000..ed0eb65226
--- /dev/null
+++ b/main/musl/0002-d86af2a0-to-4992ace9.patch
@@ -0,0 +1,1083 @@
+diff --git a/arch/arm/bits/alltypes.h.in b/arch/arm/bits/alltypes.h.in
+index bd23a6a..0d750cc 100644
+--- a/arch/arm/bits/alltypes.h.in
++++ b/arch/arm/bits/alltypes.h.in
+@@ -17,7 +17,7 @@ TYPEDEF long time_t;
+ TYPEDEF long suseconds_t;
+
+ TYPEDEF struct { union { int __i[9]; unsigned __s[9]; } __u; } pthread_attr_t;
+-TYPEDEF struct { union { int __i[6]; void *__p[6]; } __u; } pthread_mutex_t;
++TYPEDEF struct { union { int __i[6]; volatile void *volatile __p[6]; } __u; } pthread_mutex_t;
+ TYPEDEF struct { union { int __i[12]; void *__p[12]; } __u; } pthread_cond_t;
+ TYPEDEF struct { union { int __i[8]; void *__p[8]; } __u; } pthread_rwlock_t;
+ TYPEDEF struct { union { int __i[5]; void *__p[5]; } __u; } pthread_barrier_t;
+diff --git a/arch/i386/bits/alltypes.h.in b/arch/i386/bits/alltypes.h.in
+index efd2c07..502c882 100644
+--- a/arch/i386/bits/alltypes.h.in
++++ b/arch/i386/bits/alltypes.h.in
+@@ -31,7 +31,7 @@ TYPEDEF long time_t;
+ TYPEDEF long suseconds_t;
+
+ TYPEDEF struct { union { int __i[9]; unsigned __s[9]; } __u; } pthread_attr_t;
+-TYPEDEF struct { union { int __i[6]; void *__p[6]; } __u; } pthread_mutex_t;
++TYPEDEF struct { union { int __i[6]; volatile void *volatile __p[6]; } __u; } pthread_mutex_t;
+ TYPEDEF struct { union { int __i[12]; void *__p[12]; } __u; } pthread_cond_t;
+ TYPEDEF struct { union { int __i[8]; void *__p[8]; } __u; } pthread_rwlock_t;
+ TYPEDEF struct { union { int __i[5]; void *__p[5]; } __u; } pthread_barrier_t;
+diff --git a/arch/microblaze/bits/alltypes.h.in b/arch/microblaze/bits/alltypes.h.in
+index 6bd7942..4657d14 100644
+--- a/arch/microblaze/bits/alltypes.h.in
++++ b/arch/microblaze/bits/alltypes.h.in
+@@ -17,7 +17,7 @@ TYPEDEF long time_t;
+ TYPEDEF long suseconds_t;
+
+ TYPEDEF struct { union { int __i[9]; unsigned __s[9]; } __u; } pthread_attr_t;
+-TYPEDEF struct { union { int __i[6]; void *__p[6]; } __u; } pthread_mutex_t;
++TYPEDEF struct { union { int __i[6]; volatile void *volatile __p[6]; } __u; } pthread_mutex_t;
+ TYPEDEF struct { union { int __i[12]; void *__p[12]; } __u; } pthread_cond_t;
+ TYPEDEF struct { union { int __i[8]; void *__p[8]; } __u; } pthread_rwlock_t;
+ TYPEDEF struct { union { int __i[5]; void *__p[5]; } __u; } pthread_barrier_t;
+diff --git a/arch/mips/bits/alltypes.h.in b/arch/mips/bits/alltypes.h.in
+index 6bd7942..4657d14 100644
+--- a/arch/mips/bits/alltypes.h.in
++++ b/arch/mips/bits/alltypes.h.in
+@@ -17,7 +17,7 @@ TYPEDEF long time_t;
+ TYPEDEF long suseconds_t;
+
+ TYPEDEF struct { union { int __i[9]; unsigned __s[9]; } __u; } pthread_attr_t;
+-TYPEDEF struct { union { int __i[6]; void *__p[6]; } __u; } pthread_mutex_t;
++TYPEDEF struct { union { int __i[6]; volatile void *volatile __p[6]; } __u; } pthread_mutex_t;
+ TYPEDEF struct { union { int __i[12]; void *__p[12]; } __u; } pthread_cond_t;
+ TYPEDEF struct { union { int __i[8]; void *__p[8]; } __u; } pthread_rwlock_t;
+ TYPEDEF struct { union { int __i[5]; void *__p[5]; } __u; } pthread_barrier_t;
+diff --git a/arch/or1k/bits/alltypes.h.in b/arch/or1k/bits/alltypes.h.in
+index bd23a6a..0d750cc 100644
+--- a/arch/or1k/bits/alltypes.h.in
++++ b/arch/or1k/bits/alltypes.h.in
+@@ -17,7 +17,7 @@ TYPEDEF long time_t;
+ TYPEDEF long suseconds_t;
+
+ TYPEDEF struct { union { int __i[9]; unsigned __s[9]; } __u; } pthread_attr_t;
+-TYPEDEF struct { union { int __i[6]; void *__p[6]; } __u; } pthread_mutex_t;
++TYPEDEF struct { union { int __i[6]; volatile void *volatile __p[6]; } __u; } pthread_mutex_t;
+ TYPEDEF struct { union { int __i[12]; void *__p[12]; } __u; } pthread_cond_t;
+ TYPEDEF struct { union { int __i[8]; void *__p[8]; } __u; } pthread_rwlock_t;
+ TYPEDEF struct { union { int __i[5]; void *__p[5]; } __u; } pthread_barrier_t;
+diff --git a/arch/powerpc/bits/alltypes.h.in b/arch/powerpc/bits/alltypes.h.in
+index e9d8dd8..378124c 100644
+--- a/arch/powerpc/bits/alltypes.h.in
++++ b/arch/powerpc/bits/alltypes.h.in
+@@ -17,7 +17,7 @@ TYPEDEF long time_t;
+ TYPEDEF long suseconds_t;
+
+ TYPEDEF struct { union { int __i[9]; unsigned __s[9]; } __u; } pthread_attr_t;
+-TYPEDEF struct { union { int __i[6]; void *__p[6]; } __u; } pthread_mutex_t;
++TYPEDEF struct { union { int __i[6]; volatile void *volatile __p[6]; } __u; } pthread_mutex_t;
+ TYPEDEF struct { union { int __i[12]; void *__p[12]; } __u; } pthread_cond_t;
+ TYPEDEF struct { union { int __i[8]; void *__p[8]; } __u; } pthread_rwlock_t;
+ TYPEDEF struct { union { int __i[5]; void *__p[5]; } __u; } pthread_barrier_t;
+diff --git a/arch/sh/bits/alltypes.h.in b/arch/sh/bits/alltypes.h.in
+index e9d8dd8..378124c 100644
+--- a/arch/sh/bits/alltypes.h.in
++++ b/arch/sh/bits/alltypes.h.in
+@@ -17,7 +17,7 @@ TYPEDEF long time_t;
+ TYPEDEF long suseconds_t;
+
+ TYPEDEF struct { union { int __i[9]; unsigned __s[9]; } __u; } pthread_attr_t;
+-TYPEDEF struct { union { int __i[6]; void *__p[6]; } __u; } pthread_mutex_t;
++TYPEDEF struct { union { int __i[6]; volatile void *volatile __p[6]; } __u; } pthread_mutex_t;
+ TYPEDEF struct { union { int __i[12]; void *__p[12]; } __u; } pthread_cond_t;
+ TYPEDEF struct { union { int __i[8]; void *__p[8]; } __u; } pthread_rwlock_t;
+ TYPEDEF struct { union { int __i[5]; void *__p[5]; } __u; } pthread_barrier_t;
+diff --git a/arch/x32/bits/alltypes.h.in b/arch/x32/bits/alltypes.h.in
+index b077fc9..8930efa 100644
+--- a/arch/x32/bits/alltypes.h.in
++++ b/arch/x32/bits/alltypes.h.in
+@@ -22,7 +22,7 @@ TYPEDEF long long time_t;
+ TYPEDEF long long suseconds_t;
+
+ TYPEDEF struct { union { int __i[14]; unsigned long __s[7]; } __u; } pthread_attr_t;
+-TYPEDEF struct { union { int __i[10]; void *__p[5]; } __u; } pthread_mutex_t;
++TYPEDEF struct { union { int __i[10]; volatile void *volatile __p[5]; } __u; } pthread_mutex_t;
+ TYPEDEF struct { union { int __i[12]; void *__p[6]; } __u; } pthread_cond_t;
+ TYPEDEF struct { union { int __i[14]; void *__p[7]; } __u; } pthread_rwlock_t;
+ TYPEDEF struct { union { int __i[8]; void *__p[4]; } __u; } pthread_barrier_t;
+diff --git a/arch/x86_64/bits/alltypes.h.in b/arch/x86_64/bits/alltypes.h.in
+index 277e944..34b7d6a 100644
+--- a/arch/x86_64/bits/alltypes.h.in
++++ b/arch/x86_64/bits/alltypes.h.in
+@@ -22,7 +22,7 @@ TYPEDEF long time_t;
+ TYPEDEF long suseconds_t;
+
+ TYPEDEF struct { union { int __i[14]; unsigned long __s[7]; } __u; } pthread_attr_t;
+-TYPEDEF struct { union { int __i[10]; void *__p[5]; } __u; } pthread_mutex_t;
++TYPEDEF struct { union { int __i[10]; volatile void *volatile __p[5]; } __u; } pthread_mutex_t;
+ TYPEDEF struct { union { int __i[12]; void *__p[6]; } __u; } pthread_cond_t;
+ TYPEDEF struct { union { int __i[14]; void *__p[7]; } __u; } pthread_rwlock_t;
+ TYPEDEF struct { union { int __i[8]; void *__p[4]; } __u; } pthread_barrier_t;
+diff --git a/src/internal/pthread_impl.h b/src/internal/pthread_impl.h
+index 650e811..2d090f8 100644
+--- a/src/internal/pthread_impl.h
++++ b/src/internal/pthread_impl.h
+@@ -33,9 +33,9 @@ struct pthread {
+ pthread_attr_t attr;
+ volatile int dead;
+ struct {
+- void **head;
++ volatile void *volatile head;
+ long off;
+- void *pending;
++ volatile void *volatile pending;
+ } robust_list;
+ int unblock_cancel;
+ int timer_id;
+@@ -66,16 +66,16 @@ struct __timer {
+ #define _m_prev __u.__p[3]
+ #define _m_next __u.__p[4]
+ #define _m_count __u.__i[5]
+-#define _c_mutex __u.__p[0]
++#define _c_shared __u.__p[0]
+ #define _c_seq __u.__i[2]
+ #define _c_waiters __u.__i[3]
+ #define _c_clock __u.__i[4]
+-#define _c_lock __u.__i[5]
+-#define _c_lockwait __u.__i[6]
+-#define _c_waiters2 __u.__i[7]
+-#define _c_destroy __u.__i[8]
++#define _c_lock __u.__i[8]
++#define _c_head __u.__p[1]
++#define _c_tail __u.__p[5]
+ #define _rw_lock __u.__i[0]
+ #define _rw_waiters __u.__i[1]
++#define _rw_shared __u.__i[2]
+ #define _b_lock __u.__i[0]
+ #define _b_waiters __u.__i[1]
+ #define _b_limit __u.__i[2]
+@@ -108,8 +108,13 @@ void __unmapself(void *, size_t);
+
+ int __timedwait(volatile int *, int, clockid_t, const struct timespec *, void (*)(void *), void *, int);
+ void __wait(volatile int *, volatile int *, int, int);
+-#define __wake(addr, cnt, priv) \
+- __syscall(SYS_futex, addr, FUTEX_WAKE, (cnt)<0?INT_MAX:(cnt))
++static inline void __wake(volatile void *addr, int cnt, int priv)
++{
++ if (priv) priv = 128;
++ if (cnt<0) cnt = INT_MAX;
++ __syscall(SYS_futex, addr, FUTEX_WAKE|priv, cnt) != -EINVAL ||
++ __syscall(SYS_futex, addr, FUTEX_WAKE, cnt);
++}
+
+ void __acquire_ptc();
+ void __release_ptc();
+diff --git a/src/mman/mmap.c b/src/mman/mmap.c
+index 1917a54..56e39a7 100644
+--- a/src/mman/mmap.c
++++ b/src/mman/mmap.c
+@@ -16,8 +16,6 @@ weak_alias(dummy0, __vm_unlock);
+
+ void *__mmap(void *start, size_t len, int prot, int flags, int fd, off_t off)
+ {
+- void *ret;
+-
+ if (off & OFF_MASK) {
+ errno = EINVAL;
+ return MAP_FAILED;
+@@ -26,14 +24,15 @@ void *__mmap(void *start, size_t len, int prot, int flags, int fd, off_t off)
+ errno = ENOMEM;
+ return MAP_FAILED;
+ }
+- if (flags & MAP_FIXED) __vm_lock(-1);
++ if (flags & MAP_FIXED) {
++ __vm_lock(-1);
++ __vm_unlock();
++ }
+ #ifdef SYS_mmap2
+- ret = (void *)syscall(SYS_mmap2, start, len, prot, flags, fd, off/UNIT);
++ return (void *)syscall(SYS_mmap2, start, len, prot, flags, fd, off/UNIT);
+ #else
+- ret = (void *)syscall(SYS_mmap, start, len, prot, flags, fd, off);
++ return (void *)syscall(SYS_mmap, start, len, prot, flags, fd, off);
+ #endif
+- if (flags & MAP_FIXED) __vm_unlock();
+- return ret;
+ }
+
+ weak_alias(__mmap, mmap);
+diff --git a/src/mman/munmap.c b/src/mman/munmap.c
+index 8488d75..359c691 100644
+--- a/src/mman/munmap.c
++++ b/src/mman/munmap.c
+@@ -11,8 +11,8 @@ int __munmap(void *start, size_t len)
+ {
+ int ret;
+ __vm_lock(-1);
+- ret = syscall(SYS_munmap, start, len);
+ __vm_unlock();
++ ret = syscall(SYS_munmap, start, len);
+ return ret;
+ }
+
+diff --git a/src/thread/__timedwait.c b/src/thread/__timedwait.c
+index 302273a..39eb996 100644
+--- a/src/thread/__timedwait.c
++++ b/src/thread/__timedwait.c
+@@ -4,12 +4,15 @@
+ #include "futex.h"
+ #include "syscall.h"
+
+-static int do_wait(volatile int *addr, int val,
+- clockid_t clk, const struct timespec *at, int priv)
++int __timedwait(volatile int *addr, int val,
++ clockid_t clk, const struct timespec *at,
++ void (*cleanup)(void *), void *arg, int priv)
+ {
+- int r;
++ int r, cs;
+ struct timespec to, *top=0;
+
++ if (priv) priv = 128;
++
+ if (at) {
+ if (at->tv_nsec >= 1000000000UL) return EINVAL;
+ if (clock_gettime(clk, &to)) return EINVAL;
+@@ -22,21 +25,12 @@ static int do_wait(volatile int *addr, int val,
+ top = &to;
+ }
+
+- r = -__syscall_cp(SYS_futex, addr, FUTEX_WAIT, val, top);
+- if (r == EINTR || r == EINVAL || r == ETIMEDOUT) return r;
+- return 0;
+-}
+-
+-int __timedwait(volatile int *addr, int val,
+- clockid_t clk, const struct timespec *at,
+- void (*cleanup)(void *), void *arg, int priv)
+-{
+- int r, cs;
+-
+ if (!cleanup) pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cs);
+ pthread_cleanup_push(cleanup, arg);
+
+- r = do_wait(addr, val, clk, at, priv);
++ r = -__syscall_cp(SYS_futex, addr, FUTEX_WAIT|priv, val, top);
++ if (r == EINVAL) r = -__syscall_cp(SYS_futex, addr, FUTEX_WAIT, val, top);
++ if (r != EINTR && r != ETIMEDOUT) r = 0;
+
+ pthread_cleanup_pop(0);
+ if (!cleanup) pthread_setcancelstate(cs, 0);
+diff --git a/src/thread/__wait.c b/src/thread/__wait.c
+index a1e4780..ec1e820 100644
+--- a/src/thread/__wait.c
++++ b/src/thread/__wait.c
+@@ -3,13 +3,15 @@
+ void __wait(volatile int *addr, volatile int *waiters, int val, int priv)
+ {
+ int spins=10000;
+- if (priv) priv = 128; priv=0;
++ if (priv) priv = 128;
+ while (spins--) {
+ if (*addr==val) a_spin();
+ else return;
+ }
+ if (waiters) a_inc(waiters);
+- while (*addr==val)
+- __syscall(SYS_futex, addr, FUTEX_WAIT|priv, val, 0);
++ while (*addr==val) {
++ __syscall(SYS_futex, addr, FUTEX_WAIT|priv, val, 0) != -EINVAL
++ || __syscall(SYS_futex, addr, FUTEX_WAIT, val, 0);
++ }
+ if (waiters) a_dec(waiters);
+ }
+diff --git a/src/thread/pthread_attr_get.c b/src/thread/pthread_attr_get.c
+index 03fc91e..3d296bf 100644
+--- a/src/thread/pthread_attr_get.c
++++ b/src/thread/pthread_attr_get.c
+@@ -75,7 +75,7 @@ int pthread_mutexattr_getprotocol(const pthread_mutexattr_t *restrict a, int *re
+ }
+ int pthread_mutexattr_getpshared(const pthread_mutexattr_t *restrict a, int *restrict pshared)
+ {
+- *pshared = a->__attr>>31;
++ *pshared = a->__attr / 128U % 2;
+ return 0;
+ }
+
+diff --git a/src/thread/pthread_barrier_wait.c b/src/thread/pthread_barrier_wait.c
+index 5e60338..6b329c9 100644
+--- a/src/thread/pthread_barrier_wait.c
++++ b/src/thread/pthread_barrier_wait.c
+@@ -87,7 +87,8 @@ int pthread_barrier_wait(pthread_barrier_t *b)
+ a_spin();
+ a_inc(&inst->finished);
+ while (inst->finished == 1)
+- __syscall(SYS_futex, &inst->finished, FUTEX_WAIT,1,0);
++ __syscall(SYS_futex,&inst->finished,FUTEX_WAIT|128,1,0) != -EINTR
++ || __syscall(SYS_futex,&inst->finished,FUTEX_WAIT,1,0);
+ return PTHREAD_BARRIER_SERIAL_THREAD;
+ }
+
+diff --git a/src/thread/pthread_cond_broadcast.c b/src/thread/pthread_cond_broadcast.c
+index 0901daf..69f840f 100644
+--- a/src/thread/pthread_cond_broadcast.c
++++ b/src/thread/pthread_cond_broadcast.c
+@@ -1,39 +1,12 @@
+ #include "pthread_impl.h"
+
++int __private_cond_signal(pthread_cond_t *, int);
++
+ int pthread_cond_broadcast(pthread_cond_t *c)
+ {
+- pthread_mutex_t *m;
+-
++ if (!c->_c_shared) return __private_cond_signal(c, -1);
+ if (!c->_c_waiters) return 0;
+-
+ a_inc(&c->_c_seq);
+-
+- /* If cond var is process-shared, simply wake all waiters. */
+- if (c->_c_mutex == (void *)-1) {
+- __wake(&c->_c_seq, -1, 0);
+- return 0;
+- }
+-
+- /* Block waiters from returning so we can use the mutex. */
+- while (a_swap(&c->_c_lock, 1))
+- __wait(&c->_c_lock, &c->_c_lockwait, 1, 1);
+- if (!c->_c_waiters)
+- goto out;
+- m = c->_c_mutex;
+-
+- /* Move waiter count to the mutex */
+- a_fetch_add(&m->_m_waiters, c->_c_waiters2);
+- c->_c_waiters2 = 0;
+-
+- /* Perform the futex requeue, waking one waiter unless we know
+- * that the calling thread holds the mutex. */
+- __syscall(SYS_futex, &c->_c_seq, FUTEX_REQUEUE,
+- !m->_m_type || (m->_m_lock&INT_MAX)!=__pthread_self()->tid,
+- INT_MAX, &m->_m_lock);
+-
+-out:
+- a_store(&c->_c_lock, 0);
+- if (c->_c_lockwait) __wake(&c->_c_lock, 1, 0);
+-
++ __wake(&c->_c_seq, -1, 0);
+ return 0;
+ }
+diff --git a/src/thread/pthread_cond_destroy.c b/src/thread/pthread_cond_destroy.c
+index a096c55..8c55516 100644
+--- a/src/thread/pthread_cond_destroy.c
++++ b/src/thread/pthread_cond_destroy.c
+@@ -2,12 +2,13 @@
+
+ int pthread_cond_destroy(pthread_cond_t *c)
+ {
+- int priv = c->_c_mutex != (void *)-1;
+- int cnt;
+- c->_c_destroy = 1;
+- if (c->_c_waiters)
+- __wake(&c->_c_seq, -1, priv);
+- while ((cnt = c->_c_waiters))
+- __wait(&c->_c_waiters, 0, cnt, priv);
++ if (c->_c_shared && c->_c_waiters) {
++ int cnt;
++ a_or(&c->_c_waiters, 0x80000000);
++ a_inc(&c->_c_seq);
++ __wake(&c->_c_seq, -1, 0);
++ while ((cnt = c->_c_waiters) & 0x7fffffff)
++ __wait(&c->_c_waiters, 0, cnt, 0);
++ }
+ return 0;
+ }
+diff --git a/src/thread/pthread_cond_init.c b/src/thread/pthread_cond_init.c
+index 357ecd5..8c484dd 100644
+--- a/src/thread/pthread_cond_init.c
++++ b/src/thread/pthread_cond_init.c
+@@ -5,7 +5,7 @@ int pthread_cond_init(pthread_cond_t *restrict c, const pthread_condattr_t *rest
+ *c = (pthread_cond_t){0};
+ if (a) {
+ c->_c_clock = a->__attr & 0x7fffffff;
+- if (a->__attr>>31) c->_c_mutex = (void *)-1;
++ if (a->__attr>>31) c->_c_shared = (void *)-1;
+ }
+ return 0;
+ }
+diff --git a/src/thread/pthread_cond_signal.c b/src/thread/pthread_cond_signal.c
+index 71bcdcd..119c00a 100644
+--- a/src/thread/pthread_cond_signal.c
++++ b/src/thread/pthread_cond_signal.c
+@@ -1,9 +1,12 @@
+ #include "pthread_impl.h"
+
++int __private_cond_signal(pthread_cond_t *, int);
++
+ int pthread_cond_signal(pthread_cond_t *c)
+ {
++ if (!c->_c_shared) return __private_cond_signal(c, 1);
+ if (!c->_c_waiters) return 0;
+ a_inc(&c->_c_seq);
+- if (c->_c_waiters) __wake(&c->_c_seq, 1, 0);
++ __wake(&c->_c_seq, 1, 0);
+ return 0;
+ }
+diff --git a/src/thread/pthread_cond_timedwait.c b/src/thread/pthread_cond_timedwait.c
+index 99d62cc..c5cf66c 100644
+--- a/src/thread/pthread_cond_timedwait.c
++++ b/src/thread/pthread_cond_timedwait.c
+@@ -1,47 +1,130 @@
+ #include "pthread_impl.h"
+
+-struct cm {
+- pthread_cond_t *c;
+- pthread_mutex_t *m;
++/*
++ * struct waiter
++ *
++ * Waiter objects have automatic storage on the waiting thread, and
++ * are used in building a linked list representing waiters currently
++ * waiting on the condition variable or a group of waiters woken
++ * together by a broadcast or signal; in the case of signal, this is a
++ * degenerate list of one member.
++ *
++ * Waiter lists attached to the condition variable itself are
++ * protected by the lock on the cv. Detached waiter lists are never
++ * modified again, but can only be traversed in reverse order, and are
++ * protected by the "barrier" locks in each node, which are unlocked
++ * in turn to control wake order.
++ *
++ * Since process-shared cond var semantics do not necessarily allow
++ * one thread to see another's automatic storage (they may be in
++ * different processes), the waiter list is not used for the
++ * process-shared case, but the structure is still used to store data
++ * needed by the cancellation cleanup handler.
++ */
++
++struct waiter {
++ struct waiter *prev, *next;
++ int state, barrier, mutex_ret;
++ int *notify;
++ pthread_mutex_t *mutex;
++ pthread_cond_t *cond;
++ int shared;
+ };
+
+-static void unwait(pthread_cond_t *c, pthread_mutex_t *m)
++/* Self-synchronized-destruction-safe lock functions */
++
++static inline void lock(volatile int *l)
+ {
+- /* Removing a waiter is non-trivial if we could be using requeue
+- * based broadcast signals, due to mutex access issues, etc. */
++ if (a_cas(l, 0, 1)) {
++ a_cas(l, 1, 2);
++ do __wait(l, 0, 2, 1);
++ while (a_cas(l, 0, 2));
++ }
++}
+
+- if (c->_c_mutex == (void *)-1) {
+- a_dec(&c->_c_waiters);
+- if (c->_c_destroy) __wake(&c->_c_waiters, 1, 0);
++static inline void unlock(volatile int *l)
++{
++ if (a_swap(l, 0)==2)
++ __wake(l, 1, 1);
++}
++
++static inline void unlock_requeue(volatile int *l, volatile int *r, int w)
++{
++ a_store(l, 0);
++ if (w) __wake(l, 1, 1);
++ else __syscall(SYS_futex, l, FUTEX_REQUEUE|128, 0, 1, r) != -EINVAL
++ || __syscall(SYS_futex, l, FUTEX_REQUEUE, 0, 1, r);
++}
++
++enum {
++ WAITING,
++ SIGNALED,
++ LEAVING,
++};
++
++static void unwait(void *arg)
++{
++ struct waiter *node = arg;
++
++ if (node->shared) {
++ pthread_cond_t *c = node->cond;
++ pthread_mutex_t *m = node->mutex;
++ if (a_fetch_add(&c->_c_waiters, -1) == -0x7fffffff)
++ __wake(&c->_c_waiters, 1, 0);
++ node->mutex_ret = pthread_mutex_lock(m);
+ return;
+ }
+
+- while (a_swap(&c->_c_lock, 1))
+- __wait(&c->_c_lock, &c->_c_lockwait, 1, 1);
++ int oldstate = a_cas(&node->state, WAITING, LEAVING);
++
++ if (oldstate == WAITING) {
++ /* Access to cv object is valid because this waiter was not
++ * yet signaled and a new signal/broadcast cannot return
++ * after seeing a LEAVING waiter without getting notified
++ * via the futex notify below. */
++
++ pthread_cond_t *c = node->cond;
++ lock(&c->_c_lock);
++
++ if (c->_c_head == node) c->_c_head = node->next;
++ else if (node->prev) node->prev->next = node->next;
++ if (c->_c_tail == node) c->_c_tail = node->prev;
++ else if (node->next) node->next->prev = node->prev;
++
++ unlock(&c->_c_lock);
++
++ if (node->notify) {
++ if (a_fetch_add(node->notify, -1)==1)
++ __wake(node->notify, 1, 1);
++ }
++ } else {
++ /* Lock barrier first to control wake order. */
++ lock(&node->barrier);
++ }
+
+- if (c->_c_waiters2) c->_c_waiters2--;
+- else a_dec(&m->_m_waiters);
++ node->mutex_ret = pthread_mutex_lock(node->mutex);
+
+- a_store(&c->_c_lock, 0);
+- if (c->_c_lockwait) __wake(&c->_c_lock, 1, 1);
++ if (oldstate == WAITING) return;
+
+- a_dec(&c->_c_waiters);
+- if (c->_c_destroy) __wake(&c->_c_waiters, 1, 1);
+-}
++ if (!node->next) a_inc(&node->mutex->_m_waiters);
+
+-static void cleanup(void *p)
+-{
+- struct cm *cm = p;
+- unwait(cm->c, cm->m);
+- pthread_mutex_lock(cm->m);
++ /* Unlock the barrier that's holding back the next waiter, and
++ * either wake it or requeue it to the mutex. */
++ if (node->prev) {
++ unlock_requeue(&node->prev->barrier,
++ &node->mutex->_m_lock,
++ node->mutex->_m_type & 128);
++ } else {
++ a_dec(&node->mutex->_m_waiters);
++ }
+ }
+
+ int pthread_cond_timedwait(pthread_cond_t *restrict c, pthread_mutex_t *restrict m, const struct timespec *restrict ts)
+ {
+- struct cm cm = { .c=c, .m=m };
+- int r, e=0, seq;
++ struct waiter node = { .cond = c, .mutex = m };
++ int e, seq, *fut, clock = c->_c_clock;
+
+- if (m->_m_type && (m->_m_lock&INT_MAX) != __pthread_self()->tid)
++ if ((m->_m_type&15) && (m->_m_lock&INT_MAX) != __pthread_self()->tid)
+ return EPERM;
+
+ if (ts && ts->tv_nsec >= 1000000000UL)
+@@ -49,28 +132,68 @@ int pthread_cond_timedwait(pthread_cond_t *restrict c, pthread_mutex_t *restrict
+
+ pthread_testcancel();
+
+- a_inc(&c->_c_waiters);
+-
+- if (c->_c_mutex != (void *)-1) {
+- c->_c_mutex = m;
+- while (a_swap(&c->_c_lock, 1))
+- __wait(&c->_c_lock, &c->_c_lockwait, 1, 1);
+- c->_c_waiters2++;
+- a_store(&c->_c_lock, 0);
+- if (c->_c_lockwait) __wake(&c->_c_lock, 1, 1);
++ if (c->_c_shared) {
++ node.shared = 1;
++ fut = &c->_c_seq;
++ seq = c->_c_seq;
++ a_inc(&c->_c_waiters);
++ } else {
++ lock(&c->_c_lock);
++
++ seq = node.barrier = 2;
++ fut = &node.barrier;
++ node.state = WAITING;
++ node.next = c->_c_head;
++ c->_c_head = &node;
++ if (!c->_c_tail) c->_c_tail = &node;
++ else node.next->prev = &node;
++
++ unlock(&c->_c_lock);
+ }
+
+- seq = c->_c_seq;
+-
+ pthread_mutex_unlock(m);
+
+- do e = __timedwait(&c->_c_seq, seq, c->_c_clock, ts, cleanup, &cm, 0);
+- while (c->_c_seq == seq && (!e || e==EINTR));
++ do e = __timedwait(fut, seq, clock, ts, unwait, &node, !node.shared);
++ while (*fut==seq && (!e || e==EINTR));
+ if (e == EINTR) e = 0;
+
+- unwait(c, m);
++ unwait(&node);
++
++ return node.mutex_ret ? node.mutex_ret : e;
++}
++
++int __private_cond_signal(pthread_cond_t *c, int n)
++{
++ struct waiter *p, *first=0;
++ int ref = 0, cur;
++
++ lock(&c->_c_lock);
++ for (p=c->_c_tail; n && p; p=p->prev) {
++ if (a_cas(&p->state, WAITING, SIGNALED) != WAITING) {
++ ref++;
++ p->notify = &ref;
++ } else {
++ n--;
++ if (!first) first=p;
++ }
++ }
++ /* Split the list, leaving any remainder on the cv. */
++ if (p) {
++ if (p->next) p->next->prev = 0;
++ p->next = 0;
++ } else {
++ c->_c_head = 0;
++ }
++ c->_c_tail = p;
++ unlock(&c->_c_lock);
++
++ /* Wait for any waiters in the LEAVING state to remove
++ * themselves from the list before returning or allowing
++ * signaled threads to proceed. */
++ while ((cur = ref)) __wait(&ref, 0, cur, 1);
+
+- if ((r=pthread_mutex_lock(m))) return r;
++ /* Allow first signaled waiter, if any, to proceed. */
++ if (first) unlock(&first->barrier);
+
+- return e;
++ return 0;
+ }
+diff --git a/src/thread/pthread_create.c b/src/thread/pthread_create.c
+index e77e54a..c8c117b 100644
+--- a/src/thread/pthread_create.c
++++ b/src/thread/pthread_create.c
+@@ -10,6 +10,7 @@ static void dummy_0()
+ weak_alias(dummy_0, __acquire_ptc);
+ weak_alias(dummy_0, __release_ptc);
+ weak_alias(dummy_0, __pthread_tsd_run_dtors);
++weak_alias(dummy_0, __do_private_robust_list);
+
+ _Noreturn void pthread_exit(void *result)
+ {
+@@ -63,6 +64,8 @@ _Noreturn void pthread_exit(void *result)
+ a_dec(&libc.bytelocale_cnt_minus_1);
+ }
+
++ __do_private_robust_list();
++
+ if (self->detached && self->map_base) {
+ /* Detached threads must avoid the kernel clear_child_tid
+ * feature, since the virtual address will have been
+diff --git a/src/thread/pthread_mutex_consistent.c b/src/thread/pthread_mutex_consistent.c
+index 65da29f..96b83b5 100644
+--- a/src/thread/pthread_mutex_consistent.c
++++ b/src/thread/pthread_mutex_consistent.c
+@@ -2,9 +2,9 @@
+
+ int pthread_mutex_consistent(pthread_mutex_t *m)
+ {
+- if (m->_m_type < 8) return EINVAL;
+- if ((m->_m_lock & 0x3fffffff) != __pthread_self()->tid)
++ if (!(m->_m_type & 8)) return EINVAL;
++ if ((m->_m_lock & 0x7fffffff) != __pthread_self()->tid)
+ return EPERM;
+- m->_m_type -= 8;
++ m->_m_type &= ~8U;
+ return 0;
+ }
+diff --git a/src/thread/pthread_mutex_init.c b/src/thread/pthread_mutex_init.c
+index 9d85a35..acf45a7 100644
+--- a/src/thread/pthread_mutex_init.c
++++ b/src/thread/pthread_mutex_init.c
+@@ -3,6 +3,6 @@
+ int pthread_mutex_init(pthread_mutex_t *restrict m, const pthread_mutexattr_t *restrict a)
+ {
+ *m = (pthread_mutex_t){0};
+- if (a) m->_m_type = a->__attr & 7;
++ if (a) m->_m_type = a->__attr;
+ return 0;
+ }
+diff --git a/src/thread/pthread_mutex_lock.c b/src/thread/pthread_mutex_lock.c
+index 42b5af6..2a9a3aa 100644
+--- a/src/thread/pthread_mutex_lock.c
++++ b/src/thread/pthread_mutex_lock.c
+@@ -2,7 +2,8 @@
+
+ int pthread_mutex_lock(pthread_mutex_t *m)
+ {
+- if (m->_m_type == PTHREAD_MUTEX_NORMAL && !a_cas(&m->_m_lock, 0, EBUSY))
++ if ((m->_m_type&15) == PTHREAD_MUTEX_NORMAL
++ && !a_cas(&m->_m_lock, 0, EBUSY))
+ return 0;
+
+ return pthread_mutex_timedlock(m, 0);
+diff --git a/src/thread/pthread_mutex_timedlock.c b/src/thread/pthread_mutex_timedlock.c
+index 7b1afc0..2a959d2 100644
+--- a/src/thread/pthread_mutex_timedlock.c
++++ b/src/thread/pthread_mutex_timedlock.c
+@@ -2,21 +2,23 @@
+
+ int pthread_mutex_timedlock(pthread_mutex_t *restrict m, const struct timespec *restrict at)
+ {
+- int r, t;
+-
+- if (m->_m_type == PTHREAD_MUTEX_NORMAL && !a_cas(&m->_m_lock, 0, EBUSY))
++ if ((m->_m_type&15) == PTHREAD_MUTEX_NORMAL
++ && !a_cas(&m->_m_lock, 0, EBUSY))
+ return 0;
+
++ int r, t, priv = (m->_m_type & 128) ^ 128;
++
+ while ((r=pthread_mutex_trylock(m)) == EBUSY) {
+- if (!(r=m->_m_lock) || (r&0x40000000)) continue;
++ if (!(r=m->_m_lock) || ((r&0x40000000) && (m->_m_type&4)))
++ continue;
+ if ((m->_m_type&3) == PTHREAD_MUTEX_ERRORCHECK
+- && (r&0x1fffffff) == __pthread_self()->tid)
++ && (r&0x7fffffff) == __pthread_self()->tid)
+ return EDEADLK;
+
+ a_inc(&m->_m_waiters);
+ t = r | 0x80000000;
+ a_cas(&m->_m_lock, r, t);
+- r = __timedwait(&m->_m_lock, t, CLOCK_REALTIME, at, 0, 0, 0);
++ r = __timedwait(&m->_m_lock, t, CLOCK_REALTIME, at, 0, 0, priv);
+ a_dec(&m->_m_waiters);
+ if (r && r != EINTR) break;
+ }
+diff --git a/src/thread/pthread_mutex_trylock.c b/src/thread/pthread_mutex_trylock.c
+index 00ad65d..e851517 100644
+--- a/src/thread/pthread_mutex_trylock.c
++++ b/src/thread/pthread_mutex_trylock.c
+@@ -1,52 +1,58 @@
+ #include "pthread_impl.h"
+
+-int pthread_mutex_trylock(pthread_mutex_t *m)
++int __pthread_mutex_trylock_owner(pthread_mutex_t *m)
+ {
+- int tid, old, own;
+- pthread_t self;
+-
+- if (m->_m_type == PTHREAD_MUTEX_NORMAL)
+- return a_cas(&m->_m_lock, 0, EBUSY) & EBUSY;
+-
+- self = __pthread_self();
+- tid = self->tid;
+-
+- if (m->_m_type >= 4) {
+- if (!self->robust_list.off)
+- __syscall(SYS_set_robust_list,
+- &self->robust_list, 3*sizeof(long));
++ int old, own;
++ int type = m->_m_type & 15;
++ pthread_t self = __pthread_self();
++ int tid = self->tid;
++
++ if (!self->robust_list.off) {
++ __syscall(SYS_set_robust_list, &self->robust_list, 3*sizeof(long));
++ self->robust_list.head = &self->robust_list.head;
+ self->robust_list.off = (char*)&m->_m_lock-(char *)&m->_m_next;
+- self->robust_list.pending = &m->_m_next;
+ }
+
+ old = m->_m_lock;
+ own = old & 0x7fffffff;
+- if (own == tid && (m->_m_type&3) == PTHREAD_MUTEX_RECURSIVE) {
++ if (own == tid && (type&3) == PTHREAD_MUTEX_RECURSIVE) {
+ if ((unsigned)m->_m_count >= INT_MAX) return EAGAIN;
+ m->_m_count++;
+ return 0;
+ }
++ if (own == 0x40000000) return ENOTRECOVERABLE;
+
+- if ((own && !(own & 0x40000000)) || a_cas(&m->_m_lock, old, tid)!=old)
+- return EBUSY;
+-
+- if (m->_m_type < 4) return 0;
++ if (m->_m_type & 128) {
++ if (m->_m_waiters) tid |= 0x80000000;
++ self->robust_list.pending = &m->_m_next;
++ }
+
+- if (m->_m_type >= 8) {
+- m->_m_lock = 0;
+- return ENOTRECOVERABLE;
++ if ((own && (!(own & 0x40000000) || !(type & 4)))
++ || a_cas(&m->_m_lock, old, tid) != old) {
++ self->robust_list.pending = 0;
++ return EBUSY;
+ }
+- m->_m_next = self->robust_list.head;
++
++ volatile void *next = self->robust_list.head;
++ m->_m_next = next;
+ m->_m_prev = &self->robust_list.head;
+- if (self->robust_list.head)
+- self->robust_list.head[-1] = &m->_m_next;
++ if (next != &self->robust_list.head) *(volatile void *volatile *)
++ ((char *)next - sizeof(void *)) = &m->_m_next;
+ self->robust_list.head = &m->_m_next;
+ self->robust_list.pending = 0;
++
+ if (own) {
+ m->_m_count = 0;
+- m->_m_type += 8;
++ m->_m_type |= 8;
+ return EOWNERDEAD;
+ }
+
+ return 0;
+ }
++
++int pthread_mutex_trylock(pthread_mutex_t *m)
++{
++ if ((m->_m_type&15) == PTHREAD_MUTEX_NORMAL)
++ return a_cas(&m->_m_lock, 0, EBUSY) & EBUSY;
++ return __pthread_mutex_trylock_owner(m);
++}
+diff --git a/src/thread/pthread_mutex_unlock.c b/src/thread/pthread_mutex_unlock.c
+index b4bd74b..46761d9 100644
+--- a/src/thread/pthread_mutex_unlock.c
++++ b/src/thread/pthread_mutex_unlock.c
+@@ -8,30 +8,31 @@ int pthread_mutex_unlock(pthread_mutex_t *m)
+ pthread_t self;
+ int waiters = m->_m_waiters;
+ int cont;
+- int robust = 0;
++ int type = m->_m_type & 15;
++ int priv = (m->_m_type & 128) ^ 128;
+
+- if (m->_m_type != PTHREAD_MUTEX_NORMAL) {
+- if (!m->_m_lock)
+- return EPERM;
++ if (type != PTHREAD_MUTEX_NORMAL) {
+ self = __pthread_self();
+- if ((m->_m_lock&0x1fffffff) != self->tid)
++ if ((m->_m_lock&0x7fffffff) != self->tid)
+ return EPERM;
+- if ((m->_m_type&3) == PTHREAD_MUTEX_RECURSIVE && m->_m_count)
++ if ((type&3) == PTHREAD_MUTEX_RECURSIVE && m->_m_count)
+ return m->_m_count--, 0;
+- if (m->_m_type >= 4) {
+- robust = 1;
++ if (!priv) {
+ self->robust_list.pending = &m->_m_next;
+- *(void **)m->_m_prev = m->_m_next;
+- if (m->_m_next) ((void **)m->_m_next)[-1] = m->_m_prev;
+ __vm_lock_impl(+1);
+ }
++ volatile void *prev = m->_m_prev;
++ volatile void *next = m->_m_next;
++ *(volatile void *volatile *)prev = next;
++ if (next != &self->robust_list.head) *(volatile void *volatile *)
++ ((char *)next - sizeof(void *)) = prev;
+ }
+- cont = a_swap(&m->_m_lock, 0);
+- if (robust) {
++ cont = a_swap(&m->_m_lock, (type & 8) ? 0x40000000 : 0);
++ if (type != PTHREAD_MUTEX_NORMAL && !priv) {
+ self->robust_list.pending = 0;
+ __vm_unlock_impl();
+ }
+ if (waiters || cont<0)
+- __wake(&m->_m_lock, 1, 0);
++ __wake(&m->_m_lock, 1, priv);
+ return 0;
+ }
+diff --git a/src/thread/pthread_mutexattr_setpshared.c b/src/thread/pthread_mutexattr_setpshared.c
+index 8c7a1e2..100f6ff 100644
+--- a/src/thread/pthread_mutexattr_setpshared.c
++++ b/src/thread/pthread_mutexattr_setpshared.c
+@@ -3,7 +3,7 @@
+ int pthread_mutexattr_setpshared(pthread_mutexattr_t *a, int pshared)
+ {
+ if (pshared > 1U) return EINVAL;
+- a->__attr &= 0x7fffffff;
+- a->__attr |= pshared<<31;
++ a->__attr &= ~128U;
++ a->__attr |= pshared<<7;
+ return 0;
+ }
+diff --git a/src/thread/pthread_mutexattr_setrobust.c b/src/thread/pthread_mutexattr_setrobust.c
+index dcfa4cf..d062788 100644
+--- a/src/thread/pthread_mutexattr_setrobust.c
++++ b/src/thread/pthread_mutexattr_setrobust.c
+@@ -1,4 +1,28 @@
+ #include "pthread_impl.h"
++#include <stddef.h>
++
++void __do_private_robust_list()
++{
++ pthread_t self = __pthread_self();
++ volatile void *volatile *p;
++ volatile void *volatile *prev;
++ volatile void *volatile *next;
++ pthread_mutex_t *m;
++
++ prev = &self->robust_list.head;
++ for (p=self->robust_list.head; p&&p!=&self->robust_list.head; p=next) {
++ next = *p;
++ m = (void *)((char *)p - offsetof(pthread_mutex_t, _m_next));
++ if (!(m->_m_type & 128)) {
++ int waiters = m->_m_waiters;
++ *prev = next;
++ int cont = a_swap(&m->_m_lock, self->tid|0x40000000);
++ if (cont < 0 || waiters) __wake(&m->_m_lock, 1, 1);
++ } else {
++ prev = p;
++ }
++ }
++}
+
+ int pthread_mutexattr_setrobust(pthread_mutexattr_t *a, int robust)
+ {
+diff --git a/src/thread/pthread_once.c b/src/thread/pthread_once.c
+index e01f6d4..2eb0f93 100644
+--- a/src/thread/pthread_once.c
++++ b/src/thread/pthread_once.c
+@@ -3,7 +3,7 @@
+ static void undo(void *control)
+ {
+ a_store(control, 0);
+- __wake(control, 1, 0);
++ __wake(control, 1, 1);
+ }
+
+ int pthread_once(pthread_once_t *control, void (*init)(void))
+@@ -25,10 +25,10 @@ int pthread_once(pthread_once_t *control, void (*init)(void))
+ pthread_cleanup_pop(0);
+
+ a_store(control, 2);
+- if (waiters) __wake(control, -1, 0);
++ if (waiters) __wake(control, -1, 1);
+ return 0;
+ case 1:
+- __wait(control, &waiters, 1, 0);
++ __wait(control, &waiters, 1, 1);
+ continue;
+ case 2:
+ return 0;
+diff --git a/src/thread/pthread_rwlock_init.c b/src/thread/pthread_rwlock_init.c
+index 82df52e..a2c0b47 100644
+--- a/src/thread/pthread_rwlock_init.c
++++ b/src/thread/pthread_rwlock_init.c
+@@ -3,7 +3,6 @@
+ int pthread_rwlock_init(pthread_rwlock_t *restrict rw, const pthread_rwlockattr_t *restrict a)
+ {
+ *rw = (pthread_rwlock_t){0};
+- if (a) {
+- }
++ if (a) rw->_rw_shared = a->__attr[0]*128;
+ return 0;
+ }
+diff --git a/src/thread/pthread_rwlock_timedrdlock.c b/src/thread/pthread_rwlock_timedrdlock.c
+index c0c94c9..a2b4d44 100644
+--- a/src/thread/pthread_rwlock_timedrdlock.c
++++ b/src/thread/pthread_rwlock_timedrdlock.c
+@@ -8,7 +8,7 @@ int pthread_rwlock_timedrdlock(pthread_rwlock_t *restrict rw, const struct times
+ t = r | 0x80000000;
+ a_inc(&rw->_rw_waiters);
+ a_cas(&rw->_rw_lock, r, t);
+- r = __timedwait(&rw->_rw_lock, t, CLOCK_REALTIME, at, 0, 0, 0);
++ r = __timedwait(&rw->_rw_lock, t, CLOCK_REALTIME, at, 0, 0, rw->_rw_shared^128);
+ a_dec(&rw->_rw_waiters);
+ if (r && r != EINTR) return r;
+ }
+diff --git a/src/thread/pthread_rwlock_timedwrlock.c b/src/thread/pthread_rwlock_timedwrlock.c
+index 339a167..63a32ec 100644
+--- a/src/thread/pthread_rwlock_timedwrlock.c
++++ b/src/thread/pthread_rwlock_timedwrlock.c
+@@ -8,7 +8,7 @@ int pthread_rwlock_timedwrlock(pthread_rwlock_t *restrict rw, const struct times
+ t = r | 0x80000000;
+ a_inc(&rw->_rw_waiters);
+ a_cas(&rw->_rw_lock, r, t);
+- r = __timedwait(&rw->_rw_lock, t, CLOCK_REALTIME, at, 0, 0, 0);
++ r = __timedwait(&rw->_rw_lock, t, CLOCK_REALTIME, at, 0, 0, rw->_rw_shared^128);
+ a_dec(&rw->_rw_waiters);
+ if (r && r != EINTR) return r;
+ }
+diff --git a/src/thread/pthread_rwlock_unlock.c b/src/thread/pthread_rwlock_unlock.c
+index a6d2085..7b5eec8 100644
+--- a/src/thread/pthread_rwlock_unlock.c
++++ b/src/thread/pthread_rwlock_unlock.c
+@@ -2,7 +2,7 @@
+
+ int pthread_rwlock_unlock(pthread_rwlock_t *rw)
+ {
+- int val, cnt, waiters, new;
++ int val, cnt, waiters, new, priv = rw->_rw_shared^128;
+
+ do {
+ val = rw->_rw_lock;
+@@ -12,7 +12,7 @@ int pthread_rwlock_unlock(pthread_rwlock_t *rw)
+ } while (a_cas(&rw->_rw_lock, val, new) != val);
+
+ if (!new && (waiters || val<0))
+- __wake(&rw->_rw_lock, cnt, 0);
++ __wake(&rw->_rw_lock, cnt, priv);
+
+ return 0;
+ }
+diff --git a/src/thread/sem_init.c b/src/thread/sem_init.c
+index e8e419c..5509243 100644
+--- a/src/thread/sem_init.c
++++ b/src/thread/sem_init.c
+@@ -10,5 +10,6 @@ int sem_init(sem_t *sem, int pshared, unsigned value)
+ }
+ sem->__val[0] = value;
+ sem->__val[1] = 0;
++ sem->__val[2] = pshared ? 0 : 128;
+ return 0;
+ }
+diff --git a/src/thread/sem_post.c b/src/thread/sem_post.c
+index 14a2dfe..31e3293 100644
+--- a/src/thread/sem_post.c
++++ b/src/thread/sem_post.c
+@@ -3,7 +3,7 @@
+
+ int sem_post(sem_t *sem)
+ {
+- int val, waiters;
++ int val, waiters, priv = sem->__val[2];
+ do {
+ val = sem->__val[0];
+ waiters = sem->__val[1];
+@@ -12,6 +12,6 @@ int sem_post(sem_t *sem)
+ return -1;
+ }
+ } while (a_cas(sem->__val, val, val+1+(val<0)) != val);
+- if (val<0 || waiters) __wake(sem->__val, 1, 0);
++ if (val<0 || waiters) __wake(sem->__val, 1, priv);
+ return 0;
+ }
+diff --git a/src/thread/sem_timedwait.c b/src/thread/sem_timedwait.c
+index 6d0d011..bfcb6dc 100644
+--- a/src/thread/sem_timedwait.c
++++ b/src/thread/sem_timedwait.c
+@@ -12,7 +12,7 @@ int sem_timedwait(sem_t *restrict sem, const struct timespec *restrict at)
+ int r;
+ a_inc(sem->__val+1);
+ a_cas(sem->__val, 0, -1);
+- r = __timedwait(sem->__val, -1, CLOCK_REALTIME, at, cleanup, sem->__val+1, 0);
++ r = __timedwait(sem->__val, -1, CLOCK_REALTIME, at, cleanup, sem->__val+1, sem->__val[2]);
+ a_dec(sem->__val+1);
+ if (r) {
+ errno = r;
diff --git a/main/musl/APKBUILD b/main/musl/APKBUILD
index 806e37c847..925f017421 100644
--- a/main/musl/APKBUILD
+++ b/main/musl/APKBUILD
@@ -2,7 +2,7 @@
# Maintainer: Timo Teräs <timo.teras@iki.fi>
pkgname=musl
pkgver=1.1.4
-pkgrel=3
+pkgrel=4
pkgdesc="the musl c library (libc) implementation"
url="http://www.musl-libc.org/"
arch="all"
@@ -14,6 +14,7 @@ install="$pkgname.post-upgrade"
subpackages="$pkgname-dev $pkgname-utils $pkgname-dbg"
source="http://www.musl-libc.org/releases/musl-$pkgver.tar.gz
0001-v1.1.4-to-d86af2a0.patch
+ 0002-d86af2a0-to-4992ace9.patch
1001-add-basic-dns-record-parsing-functions.patch
1002-fix-handling-of-zero-length-domain-names-in-dn_expan.patch
1003-remove-ulimit-fiddling-from-setxid.patch
@@ -121,6 +122,7 @@ utils() {
md5sums="f18f3bdbe088438cd64a5313c19a7312 musl-1.1.4.tar.gz
7e6f4c4e0992f73d61963959d7fbbaa5 0001-v1.1.4-to-d86af2a0.patch
+04eef5b44c0b56b79055340bee1febc2 0002-d86af2a0-to-4992ace9.patch
2371eb1ce057fcb709a0e6a81f0d356c 1001-add-basic-dns-record-parsing-functions.patch
4b0771addf78eb0c4f0210792c99335a 1002-fix-handling-of-zero-length-domain-names-in-dn_expan.patch
71b2a4dcc39c436a6b89173943424043 1003-remove-ulimit-fiddling-from-setxid.patch
@@ -132,6 +134,7 @@ md5sums="f18f3bdbe088438cd64a5313c19a7312 musl-1.1.4.tar.gz
45f92f8d59cf84d765de698a9578dbf4 iconv.c"
sha256sums="658c65ad3c3a9b281a96c5281e75720c758d91fcaae35ab987f2fdfb4f88f5cd musl-1.1.4.tar.gz
2966fe530dfda4affca61375d16a4d03140ddf3beb39df90b9f5f0b10558eb5d 0001-v1.1.4-to-d86af2a0.patch
+c7521464f3096befb5b44d303819e9169a43a6a5a3c93566ac1cdf523a6a389d 0002-d86af2a0-to-4992ace9.patch
75053a31f6b84a64846d92c0ec631c76d7f747a9c0dc92a6dc1aa1bddfe2ea76 1001-add-basic-dns-record-parsing-functions.patch
65129391cbc63cda4387f6dae13cc91b346cf5d9a936494dbc4d4a7687af49a0 1002-fix-handling-of-zero-length-domain-names-in-dn_expan.patch
fb542c2bd5081ff2f601c519edb3dac8f54ca5c888f44bc6cfb84e6565472025 1003-remove-ulimit-fiddling-from-setxid.patch
@@ -143,6 +146,7 @@ d87d0cbb3690ae2c5d8cc218349fd8278b93855dd625deaf7ae50e320aad247c getconf.c
f79a2930a2e5bb0624321589edf8b889d1e9b603e01e6b7ae214616605b3fdd7 iconv.c"
sha512sums="a46fb1db23f518beaa959e9bebcb3bf0574e583c197792d30dcd52b3974e3c285594984207043d317859fc5552f1d303a5686e9fbe3b8825df6346de7f917f9f musl-1.1.4.tar.gz
6ef512bd4c05ae3a24493c4cffeac71953bb7383aaf88d2012f95b1e13dfa5f09ad3fc24b7f0d08e0d3788bcdf7195a1a8e639ec56b2ac01551a403398ac003e 0001-v1.1.4-to-d86af2a0.patch
+0e892a0d0e2abf09cb52d27759769a4cdd39ebd87fb1af89f502da00a4c9453309291aeb69862d60d88a8d0a0c2517aabcc92b50214d67279b12113b3c5a0157 0002-d86af2a0-to-4992ace9.patch
5b8ffa0a50419581adbf6ce2dae5797774022551c6331fa5aa2ff13635eb72b74eedd8a92cb478d45d73e1956af2f588669681ac414f3a255abd4d8ba8579448 1001-add-basic-dns-record-parsing-functions.patch
3ffe3eb575ddc0f17abb952a1effd1545fd8d81c019b2f700f74d811f5c076ae20c332df755866c74dfffa9909e7900e667d3d73992d0ca85279056ce623fee3 1002-fix-handling-of-zero-length-domain-names-in-dn_expan.patch
dae010b45419fcab64410568466f659cdc874e63113025e2cbc2fbab047b470fec23851ecbef08886505924482a069caf37c16b483b6922535fbd31832f1c4a3 1003-remove-ulimit-fiddling-from-setxid.patch
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-16 10:15:24 +0000