Adding upstream version 0.0~git20221206.8b7148f.upstream/0.0_git20221206.8b7148f

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

196 files changed, 5231 insertions, 0 deletions

diff --git a/libc-top-half/musl/src/thread/__lock.c b/libc-top-half/musl/src/thread/__lock.c
new file mode 100644
index 0000000..60eece4
--- /dev/null
+++ b/libc-top-half/musl/src/thread/__lock.c
@@ -0,0 +1,62 @@
+#include "pthread_impl.h"
+
+/* This lock primitive combines a flag (in the sign bit) and a
+ * congestion count (= threads inside the critical section, CS) in a
+ * single int that is accessed through atomic operations. The states
+ * of the int for value x are:
+ *
+ * x == 0: unlocked and no thread inside the critical section
+ *
+ * x < 0: locked with a congestion of x-INT_MIN, including the thread
+ * that holds the lock
+ *
+ * x > 0: unlocked with a congestion of x
+ *
+ * or in an equivalent formulation x is the congestion count or'ed
+ * with INT_MIN as a lock flag.
+ */
+
+void __lock(volatile int *l)
+{
+	int need_locks = libc.need_locks;
+	if (!need_locks) return;
+	/* fast path: INT_MIN for the lock, +1 for the congestion */
+	int current = a_cas(l, 0, INT_MIN + 1);
+	if (need_locks < 0) libc.need_locks = 0;
+	if (!current) return;
+	/* A first spin loop, for medium congestion. */
+	for (unsigned i = 0; i < 10; ++i) {
+		if (current < 0) current -= INT_MIN + 1;
+		// assertion: current >= 0
+		int val = a_cas(l, current, INT_MIN + (current + 1));
+		if (val == current) return;
+		current = val;
+	}
+	// Spinning failed, so mark ourselves as being inside the CS.
+	current = a_fetch_add(l, 1) + 1;
+	/* The main lock acquisition loop for heavy congestion. The only
+	 * change to the value performed inside that loop is a successful
+	 * lock via the CAS that acquires the lock. */
+	for (;;) {
+		/* We can only go into wait, if we know that somebody holds the
+		 * lock and will eventually wake us up, again. */
+		if (current < 0) {
+			__futexwait(l, current, 1);
+			current -= INT_MIN + 1;
+		}
+		/* assertion: current > 0, the count includes us already. */
+		int val = a_cas(l, current, INT_MIN + current);
+		if (val == current) return;
+		current = val;
+	}
+}
+
+void __unlock(volatile int *l)
+{
+	/* Check l[0] to see if we are multi-threaded. */
+	if (l[0] < 0) {
+		if (a_fetch_add(l, -(INT_MIN + 1)) != (INT_MIN + 1)) {
+			__wake(l, 1, 1);
+		}
+	}
+}
diff --git a/libc-top-half/musl/src/thread/__set_thread_area.c b/libc-top-half/musl/src/thread/__set_thread_area.c
new file mode 100644
index 0000000..152a6a2
--- /dev/null
+++ b/libc-top-half/musl/src/thread/__set_thread_area.c
@@ -0,0 +1,10 @@
+#include "pthread_impl.h"
+
+int __set_thread_area(void *p)
+{
+#ifdef SYS_set_thread_area
+	return __syscall(SYS_set_thread_area, p);
+#else
+	return -ENOSYS;
+#endif
+}
diff --git a/libc-top-half/musl/src/thread/__syscall_cp.c b/libc-top-half/musl/src/thread/__syscall_cp.c
new file mode 100644
index 0000000..42a0167
--- /dev/null
+++ b/libc-top-half/musl/src/thread/__syscall_cp.c
@@ -0,0 +1,20 @@
+#include "pthread_impl.h"
+#include "syscall.h"
+
+hidden long __syscall_cp_c();
+
+static long sccp(syscall_arg_t nr,
+                 syscall_arg_t u, syscall_arg_t v, syscall_arg_t w,
+                 syscall_arg_t x, syscall_arg_t y, syscall_arg_t z)
+{
+	return __syscall(nr, u, v, w, x, y, z);
+}
+
+weak_alias(sccp, __syscall_cp_c);
+
+long (__syscall_cp)(syscall_arg_t nr,
+                    syscall_arg_t u, syscall_arg_t v, syscall_arg_t w,
+                    syscall_arg_t x, syscall_arg_t y, syscall_arg_t z)
+{
+	return __syscall_cp_c(nr, u, v, w, x, y, z);
+}
diff --git a/libc-top-half/musl/src/thread/__timedwait.c b/libc-top-half/musl/src/thread/__timedwait.c
new file mode 100644
index 0000000..7d6f6be
--- /dev/null
+++ b/libc-top-half/musl/src/thread/__timedwait.c
@@ -0,0 +1,84 @@
+#include <pthread.h>
+#include <time.h>
+#include <errno.h>
+#include "futex.h"
+#include "syscall.h"
+#include "pthread_impl.h"
+
+#ifdef __wasilibc_unmodified_upstream
+#define IS32BIT(x) !((x)+0x80000000ULL>>32)
+#define CLAMP(x) (int)(IS32BIT(x) ? (x) : 0x7fffffffU+((0ULL+(x))>>63))
+
+static int __futex4_cp(volatile void *addr, int op, int val, const struct timespec *to)
+{
+	int r;
+#ifdef SYS_futex_time64
+	time_t s = to ? to->tv_sec : 0;
+	long ns = to ? to->tv_nsec : 0;
+	r = -ENOSYS;
+	if (SYS_futex == SYS_futex_time64 || !IS32BIT(s))
+		r = __syscall_cp(SYS_futex_time64, addr, op, val,
+			to ? ((long long[]){s, ns}) : 0);
+	if (SYS_futex == SYS_futex_time64 || r!=-ENOSYS) return r;
+	to = to ? (void *)(long[]){CLAMP(s), ns} : 0;
+#endif
+	r = __syscall_cp(SYS_futex, addr, op, val, to);
+	if (r != -ENOSYS) return r;
+	return __syscall_cp(SYS_futex, addr, op & ~FUTEX_PRIVATE, val, to);
+}
+
+static volatile int dummy = 0;
+weak_alias(dummy, __eintr_valid_flag);
+#else
+static int __futex4_cp(volatile void *addr, int op, int val, const struct timespec *to)
+{
+	int64_t max_wait_ns = -1;
+	if (to) {
+		max_wait_ns = (int64_t)(to->tv_sec * 1000000000 + to->tv_nsec);
+	}
+	return __wasilibc_futex_wait(addr, op, val, max_wait_ns);
+}
+#endif
+
+int __timedwait_cp(volatile int *addr, int val,
+	clockid_t clk, const struct timespec *at, int priv)
+{
+	int r;
+	struct timespec to, *top=0;
+
+	if (priv) priv = FUTEX_PRIVATE;
+
+	if (at) {
+		if (at->tv_nsec >= 1000000000UL) return EINVAL;
+		if (__clock_gettime(clk, &to)) return EINVAL;
+		to.tv_sec = at->tv_sec - to.tv_sec;
+		if ((to.tv_nsec = at->tv_nsec - to.tv_nsec) < 0) {
+			to.tv_sec--;
+			to.tv_nsec += 1000000000;
+		}
+		if (to.tv_sec < 0) return ETIMEDOUT;
+		top = &to;
+	}
+
+	r = -__futex4_cp(addr, FUTEX_WAIT|priv, val, top);
+	if (r != EINTR && r != ETIMEDOUT && r != ECANCELED) r = 0;
+#ifdef __wasilibc_unmodified_upstream
+	/* Mitigate bug in old kernels wrongly reporting EINTR for non-
+	 * interrupting (SA_RESTART) signal handlers. This is only practical
+	 * when NO interrupting signal handlers have been installed, and
+	 * works by sigaction tracking whether that's the case. */
+	if (r == EINTR && !__eintr_valid_flag) r = 0;
+#endif
+
+	return r;
+}
+
+int __timedwait(volatile int *addr, int val,
+	clockid_t clk, const struct timespec *at, int priv)
+{
+	int cs, r;
+	__pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cs);
+	r = __timedwait_cp(addr, val, clk, at, priv);
+	__pthread_setcancelstate(cs, 0);
+	return r;
+}
diff --git a/libc-top-half/musl/src/thread/__tls_get_addr.c b/libc-top-half/musl/src/thread/__tls_get_addr.c
new file mode 100644
index 0000000..19524fe
--- /dev/null
+++ b/libc-top-half/musl/src/thread/__tls_get_addr.c
@@ -0,0 +1,7 @@
+#include "pthread_impl.h"
+
+void *__tls_get_addr(tls_mod_off_t *v)
+{
+	pthread_t self = __pthread_self();
+	return (void *)(self->dtv[v[0]] + v[1]);
+}
diff --git a/libc-top-half/musl/src/thread/__unmapself.c b/libc-top-half/musl/src/thread/__unmapself.c
new file mode 100644
index 0000000..31d94e6
--- /dev/null
+++ b/libc-top-half/musl/src/thread/__unmapself.c
@@ -0,0 +1,24 @@
+#include "pthread_impl.h"
+#include "atomic.h"
+#include "syscall.h"
+/* cheat and reuse CRTJMP macro from dynlink code */
+#include "dynlink.h"
+
+static void *unmap_base;
+static size_t unmap_size;
+static char shared_stack[256];
+
+static void do_unmap()
+{
+	__syscall(SYS_munmap, unmap_base, unmap_size);
+	__syscall(SYS_exit);
+}
+
+void __unmapself(void *base, size_t size)
+{
+	char *stack = shared_stack + sizeof shared_stack;
+	stack -= (uintptr_t)stack % 16;
+	unmap_base = base;
+	unmap_size = size;
+	CRTJMP(do_unmap, stack);
+}
diff --git a/libc-top-half/musl/src/thread/__wait.c b/libc-top-half/musl/src/thread/__wait.c
new file mode 100644
index 0000000..c0e4aac
--- /dev/null
+++ b/libc-top-half/musl/src/thread/__wait.c
@@ -0,0 +1,55 @@
+#include "pthread_impl.h"
+#ifndef __wasilibc_unmodified_upstream
+#include "assert.h"
+#endif
+
+#ifndef __wasilibc_unmodified_upstream
+// Use WebAssembly's `wait` instruction to implement a futex. Note that `op` is
+// unused but retained as a parameter to match the original signature of the
+// syscall and that, for `max_wait_ns`, -1 (or any negative number) means wait
+// indefinitely.
+//
+// Adapted from Emscripten: see
+// https://github.com/emscripten-core/emscripten/blob/058a9fff/system/lib/pthread/emscripten_futex_wait.c#L111-L150.
+int __wasilibc_futex_wait(volatile void *addr, int op, int val, int64_t max_wait_ns)
+{
+    if ((((intptr_t)addr) & 3) != 0) {
+        return -EINVAL;
+    }
+
+    int ret = __builtin_wasm_memory_atomic_wait32((int *)addr, val, max_wait_ns);
+
+    // memory.atomic.wait32 returns:
+    //   0 => "ok", woken by another agent.
+    //   1 => "not-equal", loaded value != expected value
+    //   2 => "timed-out", the timeout expired
+    if (ret == 1) {
+        return -EWOULDBLOCK;
+    }
+    if (ret == 2) {
+        return -ETIMEDOUT;
+    }
+    assert(ret == 0);
+    return 0;
+}
+#endif
+
+void __wait(volatile int *addr, volatile int *waiters, int val, int priv)
+{
+	int spins=100;
+	if (priv) priv = FUTEX_PRIVATE;
+	while (spins-- && (!waiters || !*waiters)) {
+		if (*addr==val) a_spin();
+		else return;
+	}
+	if (waiters) a_inc(waiters);
+	while (*addr==val) {
+#ifdef __wasilibc_unmodified_upstream
+		__syscall(SYS_futex, addr, FUTEX_WAIT|priv, val, 0) != -ENOSYS
+		|| __syscall(SYS_futex, addr, FUTEX_WAIT, val, 0);
+#else
+		__wasilibc_futex_wait(addr, FUTEX_WAIT, val, 0);
+#endif
+	}
+	if (waiters) a_dec(waiters);
+}
diff --git a/libc-top-half/musl/src/thread/aarch64/__set_thread_area.s b/libc-top-half/musl/src/thread/aarch64/__set_thread_area.s
new file mode 100644
index 0000000..fd0df34
--- /dev/null
+++ b/libc-top-half/musl/src/thread/aarch64/__set_thread_area.s
@@ -0,0 +1,7 @@
+.global __set_thread_area
+.hidden __set_thread_area
+.type   __set_thread_area,@function
+__set_thread_area:
+	msr tpidr_el0,x0
+	mov w0,#0
+	ret
diff --git a/libc-top-half/musl/src/thread/aarch64/__unmapself.s b/libc-top-half/musl/src/thread/aarch64/__unmapself.s
new file mode 100644
index 0000000..2c5d254
--- /dev/null
+++ b/libc-top-half/musl/src/thread/aarch64/__unmapself.s
@@ -0,0 +1,7 @@
+.global __unmapself
+.type   __unmapself,%function
+__unmapself:
+	mov x8,#215 // SYS_munmap
+	svc 0
+	mov x8,#93 // SYS_exit
+	svc 0
diff --git a/libc-top-half/musl/src/thread/aarch64/clone.s b/libc-top-half/musl/src/thread/aarch64/clone.s
new file mode 100644
index 0000000..e3c8339
--- /dev/null
+++ b/libc-top-half/musl/src/thread/aarch64/clone.s
@@ -0,0 +1,30 @@
+// __clone(func, stack, flags, arg, ptid, tls, ctid)
+//         x0,   x1,    w2,    x3,  x4,   x5,  x6
+
+// syscall(SYS_clone, flags, stack, ptid, tls, ctid)
+//         x8,        x0,    x1,    x2,   x3,  x4
+
+.global __clone
+.hidden __clone
+.type   __clone,%function
+__clone:
+	// align stack and save func,arg
+	and x1,x1,#-16
+	stp x0,x3,[x1,#-16]!
+
+	// syscall
+	uxtw x0,w2
+	mov x2,x4
+	mov x3,x5
+	mov x4,x6
+	mov x8,#220 // SYS_clone
+	svc #0
+
+	cbz x0,1f
+	// parent
+	ret
+	// child
+1:	ldp x1,x0,[sp],#16
+	blr x1
+	mov x8,#93 // SYS_exit
+	svc #0
diff --git a/libc-top-half/musl/src/thread/aarch64/syscall_cp.s b/libc-top-half/musl/src/thread/aarch64/syscall_cp.s
new file mode 100644
index 0000000..41db68a
--- /dev/null
+++ b/libc-top-half/musl/src/thread/aarch64/syscall_cp.s
@@ -0,0 +1,32 @@
+// __syscall_cp_asm(&self->cancel, nr, u, v, w, x, y, z)
+//                  x0             x1  x2 x3 x4 x5 x6 x7
+
+// syscall(nr, u, v, w, x, y, z)
+//         x8  x0 x1 x2 x3 x4 x5
+
+.global __cp_begin
+.hidden __cp_begin
+.global __cp_end
+.hidden __cp_end
+.global __cp_cancel
+.hidden __cp_cancel
+.hidden __cancel
+.global __syscall_cp_asm
+.hidden __syscall_cp_asm
+.type __syscall_cp_asm,%function
+__syscall_cp_asm:
+__cp_begin:
+	ldr w0,[x0]
+	cbnz w0,__cp_cancel
+	mov x8,x1
+	mov x0,x2
+	mov x1,x3
+	mov x2,x4
+	mov x3,x5
+	mov x4,x6
+	mov x5,x7
+	svc 0
+__cp_end:
+	ret
+__cp_cancel:
+	b __cancel
diff --git a/libc-top-half/musl/src/thread/arm/__aeabi_read_tp.s b/libc-top-half/musl/src/thread/arm/__aeabi_read_tp.s
new file mode 100644
index 0000000..2585620
--- /dev/null
+++ b/libc-top-half/musl/src/thread/arm/__aeabi_read_tp.s
@@ -0,0 +1,10 @@
+.syntax unified
+.global __aeabi_read_tp
+.type __aeabi_read_tp,%function
+__aeabi_read_tp:
+	ldr r0,1f
+	add r0,r0,pc
+	ldr r0,[r0]
+2:	bx r0
+	.align 2
+1:	.word __a_gettp_ptr - 2b
diff --git a/libc-top-half/musl/src/thread/arm/__set_thread_area.c b/libc-top-half/musl/src/thread/arm/__set_thread_area.c
new file mode 100644
index 0000000..09de65a
--- /dev/null
+++ b/libc-top-half/musl/src/thread/arm/__set_thread_area.c
@@ -0,0 +1,52 @@
+#include <stdint.h>
+#include <elf.h>
+#include "pthread_impl.h"
+#include "libc.h"
+
+#define HWCAP_TLS (1 << 15)
+
+extern hidden const unsigned char
+	__a_barrier_oldkuser[], __a_barrier_v6[], __a_barrier_v7[],
+	__a_cas_v6[], __a_cas_v7[],
+	__a_gettp_cp15[];
+
+#define __a_barrier_kuser 0xffff0fa0
+#define __a_barrier_oldkuser (uintptr_t)__a_barrier_oldkuser
+#define __a_barrier_v6 (uintptr_t)__a_barrier_v6
+#define __a_barrier_v7 (uintptr_t)__a_barrier_v7
+
+#define __a_cas_kuser 0xffff0fc0
+#define __a_cas_v6 (uintptr_t)__a_cas_v6
+#define __a_cas_v7 (uintptr_t)__a_cas_v7
+
+#define __a_gettp_kuser 0xffff0fe0
+#define __a_gettp_cp15 (uintptr_t)__a_gettp_cp15
+
+extern hidden uintptr_t __a_barrier_ptr, __a_cas_ptr, __a_gettp_ptr;
+
+int __set_thread_area(void *p)
+{
+#if !__ARM_ARCH_7A__ && !__ARM_ARCH_7R__ && __ARM_ARCH < 7
+	if (__hwcap & HWCAP_TLS) {
+		size_t *aux;
+		__a_cas_ptr = __a_cas_v7;
+		__a_barrier_ptr = __a_barrier_v7;
+		for (aux=libc.auxv; *aux; aux+=2) {
+			if (*aux != AT_PLATFORM) continue;
+			const char *s = (void *)aux[1];
+			if (s[0]!='v' || s[1]!='6' || s[2]-'0'<10u) break;
+			__a_cas_ptr = __a_cas_v6;
+			__a_barrier_ptr = __a_barrier_v6;
+			break;
+		}
+	} else {
+		int ver = *(int *)0xffff0ffc;
+		__a_gettp_ptr = __a_gettp_kuser;
+		__a_cas_ptr = __a_cas_kuser;
+		__a_barrier_ptr = __a_barrier_kuser;
+		if (ver < 2) a_crash();
+		if (ver < 3) __a_barrier_ptr = __a_barrier_oldkuser;
+	}
+#endif
+	return __syscall(0xf0005, p);
+}
diff --git a/libc-top-half/musl/src/thread/arm/__unmapself.s b/libc-top-half/musl/src/thread/arm/__unmapself.s
new file mode 100644
index 0000000..29c2d07
--- /dev/null
+++ b/libc-top-half/musl/src/thread/arm/__unmapself.s
@@ -0,0 +1,9 @@
+.syntax unified
+.text
+.global __unmapself
+.type   __unmapself,%function
+__unmapself:
+	mov r7,#91
+	svc 0
+	mov r7,#1
+	svc 0
diff --git a/libc-top-half/musl/src/thread/arm/atomics.s b/libc-top-half/musl/src/thread/arm/atomics.s
new file mode 100644
index 0000000..da50508
--- /dev/null
+++ b/libc-top-half/musl/src/thread/arm/atomics.s
@@ -0,0 +1,106 @@
+.syntax unified
+.text
+
+.global __a_barrier_dummy
+.hidden __a_barrier_dummy
+.type __a_barrier_dummy,%function
+__a_barrier_dummy:
+	bx lr
+
+.global __a_barrier_oldkuser
+.hidden __a_barrier_oldkuser
+.type __a_barrier_oldkuser,%function
+__a_barrier_oldkuser:
+	push {r0,r1,r2,r3,ip,lr}
+	mov r1,r0
+	mov r2,sp
+	ldr ip,=0xffff0fc0
+	bl 1f
+	pop {r0,r1,r2,r3,ip,lr}
+	bx lr
+1:	bx ip
+
+.global __a_barrier_v6
+.hidden __a_barrier_v6
+.type __a_barrier_v6,%function
+__a_barrier_v6:
+	.arch armv6t2
+	mcr p15,0,r0,c7,c10,5
+	bx lr
+
+.global __a_barrier_v7
+.hidden __a_barrier_v7
+.type __a_barrier_v7,%function
+__a_barrier_v7:
+	.arch armv7-a
+	dmb ish
+	bx lr
+
+.global __a_cas_dummy
+.hidden __a_cas_dummy
+.type __a_cas_dummy,%function
+__a_cas_dummy:
+	mov r3,r0
+	ldr r0,[r2]
+	subs r0,r3,r0
+	streq r1,[r2]
+	bx lr
+
+.global __a_cas_v6
+.hidden __a_cas_v6
+.type __a_cas_v6,%function
+__a_cas_v6:
+	.arch armv6t2
+	mov r3,r0
+	mcr p15,0,r0,c7,c10,5
+1:	ldrex r0,[r2]
+	subs r0,r3,r0
+	strexeq r0,r1,[r2]
+	teqeq r0,#1
+	beq 1b
+	mcr p15,0,r0,c7,c10,5
+	bx lr
+
+.global __a_cas_v7
+.hidden __a_cas_v7
+.type __a_cas_v7,%function
+__a_cas_v7:
+	.arch armv7-a
+	mov r3,r0
+	dmb ish
+1:	ldrex r0,[r2]
+	subs r0,r3,r0
+	strexeq r0,r1,[r2]
+	teqeq r0,#1
+	beq 1b
+	dmb ish
+	bx lr
+
+.global __a_gettp_cp15
+.hidden __a_gettp_cp15
+.type __a_gettp_cp15,%function
+__a_gettp_cp15:
+	mrc p15,0,r0,c13,c0,3
+	bx lr
+
+/* Tag this file with minimum ISA level so as not to affect linking. */
+.object_arch armv4t
+.eabi_attribute 6,2
+
+.data
+.align 2
+
+.global __a_barrier_ptr
+.hidden __a_barrier_ptr
+__a_barrier_ptr:
+	.word __a_barrier_dummy
+
+.global __a_cas_ptr
+.hidden __a_cas_ptr
+__a_cas_ptr:
+	.word __a_cas_dummy
+
+.global __a_gettp_ptr
+.hidden __a_gettp_ptr
+__a_gettp_ptr:
+	.word __a_gettp_cp15
diff --git a/libc-top-half/musl/src/thread/arm/clone.s b/libc-top-half/musl/src/thread/arm/clone.s
new file mode 100644
index 0000000..bb0965d
--- /dev/null
+++ b/libc-top-half/musl/src/thread/arm/clone.s
@@ -0,0 +1,28 @@
+.syntax unified
+.text
+.global __clone
+.hidden __clone
+.type   __clone,%function
+__clone:
+	stmfd sp!,{r4,r5,r6,r7}
+	mov r7,#120
+	mov r6,r3
+	mov r5,r0
+	mov r0,r2
+	and r1,r1,#-16
+	ldr r2,[sp,#16]
+	ldr r3,[sp,#20]
+	ldr r4,[sp,#24]
+	svc 0
+	tst r0,r0
+	beq 1f
+	ldmfd sp!,{r4,r5,r6,r7}
+	bx lr
+
+1:	mov r0,r6
+	bl 3f
+2:	mov r7,#1
+	svc 0
+	b 2b
+
+3:	bx r5
diff --git a/libc-top-half/musl/src/thread/arm/syscall_cp.s b/libc-top-half/musl/src/thread/arm/syscall_cp.s
new file mode 100644
index 0000000..e607dd4
--- /dev/null
+++ b/libc-top-half/musl/src/thread/arm/syscall_cp.s
@@ -0,0 +1,29 @@
+.syntax unified
+.global __cp_begin
+.hidden __cp_begin
+.global __cp_end
+.hidden __cp_end
+.global __cp_cancel
+.hidden __cp_cancel
+.hidden __cancel
+.global __syscall_cp_asm
+.hidden __syscall_cp_asm
+.type __syscall_cp_asm,%function
+__syscall_cp_asm:
+	mov ip,sp
+	stmfd sp!,{r4,r5,r6,r7}
+__cp_begin:
+	ldr r0,[r0]
+	cmp r0,#0
+	bne __cp_cancel
+	mov r7,r1
+	mov r0,r2
+	mov r1,r3
+	ldmfd ip,{r2,r3,r4,r5,r6}
+	svc 0
+__cp_end:
+	ldmfd sp!,{r4,r5,r6,r7}
+	bx lr
+__cp_cancel:
+	ldmfd sp!,{r4,r5,r6,r7}
+	b __cancel
diff --git a/libc-top-half/musl/src/thread/call_once.c b/libc-top-half/musl/src/thread/call_once.c
new file mode 100644
index 0000000..5ed3018
--- /dev/null
+++ b/libc-top-half/musl/src/thread/call_once.c
@@ -0,0 +1,7 @@
+#include <threads.h>
+#include <pthread.h>
+
+void call_once(once_flag *flag, void (*func)(void))
+{
+	__pthread_once(flag, func);
+}
diff --git a/libc-top-half/musl/src/thread/clone.c b/libc-top-half/musl/src/thread/clone.c
new file mode 100644
index 0000000..be80c8e
--- /dev/null
+++ b/libc-top-half/musl/src/thread/clone.c
@@ -0,0 +1,7 @@
+#include <errno.h>
+#include "pthread_impl.h"
+
+int __clone(int (*func)(void *), void *stack, int flags, void *arg, ...)
+{
+	return -ENOSYS;
+}
diff --git a/libc-top-half/musl/src/thread/cnd_broadcast.c b/libc-top-half/musl/src/thread/cnd_broadcast.c
new file mode 100644
index 0000000..e76b5a8
--- /dev/null
+++ b/libc-top-half/musl/src/thread/cnd_broadcast.c
@@ -0,0 +1,9 @@
+#include <threads.h>
+#include <pthread.h>
+
+int cnd_broadcast(cnd_t *c)
+{
+	/* This internal function never fails, and always returns zero,
+	 * which matches the value thrd_success is defined with. */
+	return __private_cond_signal((pthread_cond_t *)c, -1);
+}
diff --git a/libc-top-half/musl/src/thread/cnd_destroy.c b/libc-top-half/musl/src/thread/cnd_destroy.c
new file mode 100644
index 0000000..453c90b
--- /dev/null
+++ b/libc-top-half/musl/src/thread/cnd_destroy.c
@@ -0,0 +1,6 @@
+#include <threads.h>
+
+void cnd_destroy(cnd_t *c)
+{
+	/* For private cv this is a no-op */
+}
diff --git a/libc-top-half/musl/src/thread/cnd_init.c b/libc-top-half/musl/src/thread/cnd_init.c
new file mode 100644
index 0000000..18c5085
--- /dev/null
+++ b/libc-top-half/musl/src/thread/cnd_init.c
@@ -0,0 +1,7 @@
+#include <threads.h>
+
+int cnd_init(cnd_t *c)
+{
+	*c = (cnd_t){ 0 };
+	return thrd_success;
+}
diff --git a/libc-top-half/musl/src/thread/cnd_signal.c b/libc-top-half/musl/src/thread/cnd_signal.c
new file mode 100644
index 0000000..02cdc6c
--- /dev/null
+++ b/libc-top-half/musl/src/thread/cnd_signal.c
@@ -0,0 +1,9 @@
+#include <threads.h>
+#include <pthread.h>
+
+int cnd_signal(cnd_t *c)
+{
+	/* This internal function never fails, and always returns zero,
+	 * which matches the value thrd_success is defined with. */
+	return __private_cond_signal((pthread_cond_t *)c, 1);
+}
diff --git a/libc-top-half/musl/src/thread/cnd_timedwait.c b/libc-top-half/musl/src/thread/cnd_timedwait.c
new file mode 100644
index 0000000..2802af5
--- /dev/null
+++ b/libc-top-half/musl/src/thread/cnd_timedwait.c
@@ -0,0 +1,14 @@
+#include <threads.h>
+#include <pthread.h>
+#include <errno.h>
+
+int cnd_timedwait(cnd_t *restrict c, mtx_t *restrict m, const struct timespec *restrict ts)
+{
+	int ret = __pthread_cond_timedwait((pthread_cond_t *)c, (pthread_mutex_t *)m, ts);
+	switch (ret) {
+	/* May also return EINVAL or EPERM. */
+	default:        return thrd_error;
+	case 0:         return thrd_success;
+	case ETIMEDOUT: return thrd_timedout;
+	}
+}
diff --git a/libc-top-half/musl/src/thread/cnd_wait.c b/libc-top-half/musl/src/thread/cnd_wait.c
new file mode 100644
index 0000000..602796f
--- /dev/null
+++ b/libc-top-half/musl/src/thread/cnd_wait.c
@@ -0,0 +1,9 @@
+#include <threads.h>
+
+int cnd_wait(cnd_t *c, mtx_t *m)
+{
+	/* Calling cnd_timedwait with a null pointer is an extension.
+	 * It is convenient here to avoid duplication of the logic
+	 * for return values. */
+	return cnd_timedwait(c, m, 0);
+}
diff --git a/libc-top-half/musl/src/thread/default_attr.c b/libc-top-half/musl/src/thread/default_attr.c
new file mode 100644
index 0000000..dce9640
--- /dev/null
+++ b/libc-top-half/musl/src/thread/default_attr.c
@@ -0,0 +1,4 @@
+#include "pthread_impl.h"
+
+unsigned __default_stacksize = DEFAULT_STACK_SIZE;
+unsigned __default_guardsize = DEFAULT_GUARD_SIZE;
diff --git a/libc-top-half/musl/src/thread/i386/__set_thread_area.s b/libc-top-half/musl/src/thread/i386/__set_thread_area.s
new file mode 100644
index 0000000..aa6852b
--- /dev/null
+++ b/libc-top-half/musl/src/thread/i386/__set_thread_area.s
@@ -0,0 +1,47 @@
+.text
+.global __set_thread_area
+.hidden __set_thread_area
+.type   __set_thread_area,@function
+__set_thread_area:
+	push %ebx
+	push $0x51
+	push $0xfffff
+	push 16(%esp)
+	call 1f
+1:	addl $4f-1b,(%esp)
+	pop %ecx
+	mov (%ecx),%edx
+	push %edx
+	mov %esp,%ebx
+	xor %eax,%eax
+	mov $243,%al
+	int $128
+	testl %eax,%eax
+	jnz 2f
+	movl (%esp),%edx
+	movl %edx,(%ecx)
+	leal 3(,%edx,8),%edx
+3:	movw %dx,%gs
+1:
+	addl $16,%esp
+	popl %ebx
+	ret
+2:
+	mov %ebx,%ecx
+	xor %eax,%eax
+	xor %ebx,%ebx
+	xor %edx,%edx
+	mov %ebx,(%esp)
+	mov $1,%bl
+	mov $16,%dl
+	mov $123,%al
+	int $128
+	testl %eax,%eax
+	jnz 1b
+	mov $7,%dl
+	inc %al
+	jmp 3b
+
+.data
+	.align 4
+4:	.long -1
diff --git a/libc-top-half/musl/src/thread/i386/__unmapself.s b/libc-top-half/musl/src/thread/i386/__unmapself.s
new file mode 100644
index 0000000..d656959
--- /dev/null
+++ b/libc-top-half/musl/src/thread/i386/__unmapself.s
@@ -0,0 +1,11 @@
+.text
+.global __unmapself
+.type   __unmapself,@function
+__unmapself:
+	movl $91,%eax
+	movl 4(%esp),%ebx
+	movl 8(%esp),%ecx
+	int $128
+	xorl %ebx,%ebx
+	movl $1,%eax
+	int $128
diff --git a/libc-top-half/musl/src/thread/i386/clone.s b/libc-top-half/musl/src/thread/i386/clone.s
new file mode 100644
index 0000000..e237d3c
--- /dev/null
+++ b/libc-top-half/musl/src/thread/i386/clone.s
@@ -0,0 +1,49 @@
+.text
+.global __clone
+.hidden __clone
+.type   __clone,@function
+__clone:
+	push %ebp
+	mov %esp,%ebp
+	push %ebx
+	push %esi
+	push %edi
+
+	xor %eax,%eax
+	push $0x51
+	mov %gs,%ax
+	push $0xfffff
+	shr $3,%eax
+	push 28(%ebp)
+	push %eax
+	mov $120,%al
+
+	mov 12(%ebp),%ecx
+	mov 16(%ebp),%ebx
+	and $-16,%ecx
+	sub $16,%ecx
+	mov 20(%ebp),%edi
+	mov %edi,(%ecx)
+	mov 24(%ebp),%edx
+	mov %esp,%esi
+	mov 32(%ebp),%edi
+	mov 8(%ebp),%ebp
+	int $128
+	test %eax,%eax
+	jnz 1f
+
+	mov %ebp,%eax
+	xor %ebp,%ebp
+	call *%eax
+	mov %eax,%ebx
+	xor %eax,%eax
+	inc %eax
+	int $128
+	hlt
+
+1:	add $16,%esp
+	pop %edi
+	pop %esi
+	pop %ebx
+	pop %ebp
+	ret
diff --git a/libc-top-half/musl/src/thread/i386/syscall_cp.s b/libc-top-half/musl/src/thread/i386/syscall_cp.s
new file mode 100644
index 0000000..7dce1eb
--- /dev/null
+++ b/libc-top-half/musl/src/thread/i386/syscall_cp.s
@@ -0,0 +1,41 @@
+.text
+.global __cp_begin
+.hidden __cp_begin
+.global __cp_end
+.hidden __cp_end
+.global __cp_cancel
+.hidden __cp_cancel
+.hidden __cancel
+.global __syscall_cp_asm
+.hidden __syscall_cp_asm
+.type   __syscall_cp_asm,@function
+__syscall_cp_asm:
+	mov 4(%esp),%ecx
+	pushl %ebx
+	pushl %esi
+	pushl %edi
+	pushl %ebp
+__cp_begin:
+	movl (%ecx),%eax
+	testl %eax,%eax
+	jnz __cp_cancel
+	movl 24(%esp),%eax
+	movl 28(%esp),%ebx
+	movl 32(%esp),%ecx
+	movl 36(%esp),%edx
+	movl 40(%esp),%esi
+	movl 44(%esp),%edi
+	movl 48(%esp),%ebp
+	int $128
+__cp_end:
+	popl %ebp
+	popl %edi
+	popl %esi
+	popl %ebx
+	ret
+__cp_cancel:
+	popl %ebp
+	popl %edi
+	popl %esi
+	popl %ebx
+	jmp __cancel
diff --git a/libc-top-half/musl/src/thread/i386/tls.s b/libc-top-half/musl/src/thread/i386/tls.s
new file mode 100644
index 0000000..6e4c4cb
--- /dev/null
+++ b/libc-top-half/musl/src/thread/i386/tls.s
@@ -0,0 +1,9 @@
+.text
+.global ___tls_get_addr
+.type ___tls_get_addr,@function
+___tls_get_addr:
+	mov %gs:4,%edx
+	mov (%eax),%ecx
+	mov 4(%eax),%eax
+	add (%edx,%ecx,4),%eax
+	ret
diff --git a/libc-top-half/musl/src/thread/lock_ptc.c b/libc-top-half/musl/src/thread/lock_ptc.c
new file mode 100644
index 0000000..7adedab
--- /dev/null
+++ b/libc-top-half/musl/src/thread/lock_ptc.c
@@ -0,0 +1,18 @@
+#include <pthread.h>
+
+static pthread_rwlock_t lock = PTHREAD_RWLOCK_INITIALIZER;
+
+void __inhibit_ptc()
+{
+	pthread_rwlock_wrlock(&lock);
+}
+
+void __acquire_ptc()
+{
+	pthread_rwlock_rdlock(&lock);
+}
+
+void __release_ptc()
+{
+	pthread_rwlock_unlock(&lock);
+}
diff --git a/libc-top-half/musl/src/thread/m68k/__m68k_read_tp.s b/libc-top-half/musl/src/thread/m68k/__m68k_read_tp.s
new file mode 100644
index 0000000..86886da
--- /dev/null
+++ b/libc-top-half/musl/src/thread/m68k/__m68k_read_tp.s
@@ -0,0 +1,8 @@
+.text
+.global __m68k_read_tp
+.type   __m68k_read_tp,@function
+__m68k_read_tp:
+	move.l #333,%d0
+	trap #0
+	move.l %d0,%a0
+	rts
diff --git a/libc-top-half/musl/src/thread/m68k/clone.s b/libc-top-half/musl/src/thread/m68k/clone.s
new file mode 100644
index 0000000..f6dfa06
--- /dev/null
+++ b/libc-top-half/musl/src/thread/m68k/clone.s
@@ -0,0 +1,25 @@
+.text
+.global __clone
+.hidden __clone
+.type   __clone,@function
+__clone:
+	movem.l %d2-%d5,-(%sp)
+	move.l #120,%d0
+	move.l 28(%sp),%d1
+	move.l 24(%sp),%d2
+	and.l #-16,%d2
+	move.l 36(%sp),%d3
+	move.l 44(%sp),%d4
+	move.l 40(%sp),%d5
+	move.l 20(%sp),%a0
+	move.l 32(%sp),%a1
+	trap #0
+	tst.l %d0
+	beq 1f
+	movem.l (%sp)+,%d2-%d5
+	rts
+1:	move.l %a1,-(%sp)
+	jsr (%a0)
+	move.l #1,%d0
+	trap #0
+	clr.b 0
diff --git a/libc-top-half/musl/src/thread/m68k/syscall_cp.s b/libc-top-half/musl/src/thread/m68k/syscall_cp.s
new file mode 100644
index 0000000..5628a89
--- /dev/null
+++ b/libc-top-half/musl/src/thread/m68k/syscall_cp.s
@@ -0,0 +1,26 @@
+.text
+.global __cp_begin
+.hidden __cp_begin
+.global __cp_end
+.hidden __cp_end
+.global __cp_cancel
+.hidden __cp_cancel
+.hidden __cancel
+.global __syscall_cp_asm
+.hidden __syscall_cp_asm
+.type   __syscall_cp_asm,@function
+__syscall_cp_asm:
+	movem.l %d2-%d5,-(%sp)
+	movea.l 20(%sp),%a0
+__cp_begin:
+	move.l (%a0),%d0
+	bne __cp_cancel
+	movem.l 24(%sp),%d0-%d5/%a0
+	trap #0
+__cp_end:
+	movem.l (%sp)+,%d2-%d5
+	rts
+__cp_cancel:
+	movem.l (%sp)+,%d2-%d5
+	move.l __cancel-.-8,%a1
+	jmp (%pc,%a1)
diff --git a/libc-top-half/musl/src/thread/microblaze/__set_thread_area.s b/libc-top-half/musl/src/thread/microblaze/__set_thread_area.s
new file mode 100644
index 0000000..9a226a9
--- /dev/null
+++ b/libc-top-half/musl/src/thread/microblaze/__set_thread_area.s
@@ -0,0 +1,7 @@
+.global __set_thread_area
+.hidden __set_thread_area
+.type   __set_thread_area,@function
+__set_thread_area:
+	ori      r21, r5, 0
+	rtsd     r15, 8
+	ori      r3, r0, 0
diff --git a/libc-top-half/musl/src/thread/microblaze/__unmapself.s b/libc-top-half/musl/src/thread/microblaze/__unmapself.s
new file mode 100644
index 0000000..b180de6
--- /dev/null
+++ b/libc-top-half/musl/src/thread/microblaze/__unmapself.s
@@ -0,0 +1,8 @@
+.global __unmapself
+.type   __unmapself,@function
+__unmapself:
+	ori     r12, r0, 91
+	brki    r14, 0x8
+	ori     r12, r0, 1
+	brki    r14, 0x8
+	nop
diff --git a/libc-top-half/musl/src/thread/microblaze/clone.s b/libc-top-half/musl/src/thread/microblaze/clone.s
new file mode 100644
index 0000000..b68cc5f
--- /dev/null
+++ b/libc-top-half/musl/src/thread/microblaze/clone.s
@@ -0,0 +1,30 @@
+.global __clone
+.hidden __clone
+.type   __clone,@function
+
+# r5, r6, r7, r8, r9, r10, stack
+# fn, st, fl, ar, pt, tl, ct
+# fl, st, __, pt, ct, tl
+
+__clone:
+	andi    r6, r6, -16
+	addi    r6, r6, -16
+	swi     r5, r6, 0
+	swi     r8, r6, 4
+
+	ori     r5, r7, 0
+	ori     r8, r9, 0
+	lwi     r9, r1, 28
+	ori     r12, r0, 120
+
+	brki    r14, 8
+	beqi	r3, 1f
+	rtsd    r15, 8
+	nop
+
+1:	lwi     r3, r1, 0
+	lwi     r5, r1, 4
+	brald   r15, r3
+	nop
+	ori     r12, r0, 1
+	brki    r14, 8
diff --git a/libc-top-half/musl/src/thread/microblaze/syscall_cp.s b/libc-top-half/musl/src/thread/microblaze/syscall_cp.s
new file mode 100644
index 0000000..b0df61c
--- /dev/null
+++ b/libc-top-half/musl/src/thread/microblaze/syscall_cp.s
@@ -0,0 +1,27 @@
+.global __cp_begin
+.hidden __cp_begin
+.global __cp_end
+.hidden __cp_end
+.global __cp_cancel
+.hidden __cp_cancel
+.hidden __cancel
+.global __syscall_cp_asm
+.hidden __syscall_cp_asm
+.type   __syscall_cp_asm,@function
+__syscall_cp_asm:
+__cp_begin:
+	lwi     r5, r5, 0
+	bnei    r5, __cp_cancel
+	addi    r12, r6, 0
+	add     r5, r7, r0
+	add     r6, r8, r0
+	add     r7, r9, r0
+	add     r8, r10, r0
+	lwi     r9, r1, 28
+	lwi     r10, r1, 32
+	brki    r14, 0x8
+__cp_end:
+	rtsd    r15, 8
+	nop
+__cp_cancel:
+	bri     __cancel
diff --git a/libc-top-half/musl/src/thread/mips/__unmapself.s b/libc-top-half/musl/src/thread/mips/__unmapself.s
new file mode 100644
index 0000000..ba139dc
--- /dev/null
+++ b/libc-top-half/musl/src/thread/mips/__unmapself.s
@@ -0,0 +1,10 @@
+.set noreorder
+.global __unmapself
+.type   __unmapself,@function
+__unmapself:
+	move $sp, $25
+	li $2, 4091
+	syscall
+	li $4, 0
+	li $2, 4001
+	syscall
diff --git a/libc-top-half/musl/src/thread/mips/clone.s b/libc-top-half/musl/src/thread/mips/clone.s
new file mode 100644
index 0000000..0446338
--- /dev/null
+++ b/libc-top-half/musl/src/thread/mips/clone.s
@@ -0,0 +1,36 @@
+.set noreorder
+.global __clone
+.hidden __clone
+.type   __clone,@function
+__clone:
+	# Save function pointer and argument pointer on new thread stack
+	and $5, $5, -8
+	subu $5, $5, 16
+	sw $4, 0($5)
+	sw $7, 4($5)
+	# Shuffle (fn,sp,fl,arg,ptid,tls,ctid) to (fl,sp,ptid,tls,ctid)
+	move $4, $6
+	lw $6, 16($sp)
+	lw $7, 20($sp)
+	lw $9, 24($sp)
+	subu $sp, $sp, 16
+	sw $9, 16($sp)
+	li $2, 4120
+	syscall
+	beq $7, $0, 1f
+	nop
+	addu $sp, $sp, 16
+	jr $ra
+	subu $2, $0, $2
+1:	beq $2, $0, 1f
+	nop
+	addu $sp, $sp, 16
+	jr $ra
+	nop
+1:	lw $25, 0($sp)
+	lw $4, 4($sp)
+	jalr $25
+	nop
+	move $4, $2
+	li $2, 4001
+	syscall
diff --git a/libc-top-half/musl/src/thread/mips/syscall_cp.s b/libc-top-half/musl/src/thread/mips/syscall_cp.s
new file mode 100644
index 0000000..d284626
--- /dev/null
+++ b/libc-top-half/musl/src/thread/mips/syscall_cp.s
@@ -0,0 +1,53 @@
+.set    noreorder
+
+.global __cp_begin
+.hidden __cp_begin
+.type   __cp_begin,@function
+.global __cp_end
+.hidden __cp_end
+.type   __cp_end,@function
+.global __cp_cancel
+.hidden __cp_cancel
+.type   __cp_cancel,@function
+.hidden __cancel
+.global __syscall_cp_asm
+.hidden __syscall_cp_asm
+.type   __syscall_cp_asm,@function
+__syscall_cp_asm:
+	subu    $sp, $sp, 32
+__cp_begin:
+	lw      $4, 0($4)
+	bne     $4, $0, __cp_cancel
+	move    $2, $5
+	move    $4, $6
+	move    $5, $7
+	lw      $6, 48($sp)
+	lw      $7, 52($sp)
+	lw      $8, 56($sp)
+	lw      $9, 60($sp)
+	lw      $10,64($sp)
+	sw      $8, 16($sp)
+	sw      $9, 20($sp)
+	sw      $10,24($sp)
+	sw      $2, 28($sp)
+	lw      $2, 28($sp)
+	syscall
+__cp_end:
+	beq     $7, $0, 1f
+	addu    $sp, $sp, 32
+	subu    $2, $0, $2
+1:	jr      $ra
+	nop
+
+__cp_cancel:
+	move    $2, $ra
+	bal     1f
+	addu    $sp, $sp, 32
+	.gpword .
+	.gpword __cancel
+1:	lw      $3, ($ra)
+	subu    $3, $ra, $3
+	lw      $25, 4($ra)
+	addu    $25, $25, $3
+	jr      $25
+	move    $ra, $2
diff --git a/libc-top-half/musl/src/thread/mips64/__unmapself.s b/libc-top-half/musl/src/thread/mips64/__unmapself.s
new file mode 100644
index 0000000..f6795cd
--- /dev/null
+++ b/libc-top-half/musl/src/thread/mips64/__unmapself.s
@@ -0,0 +1,9 @@
+.set	noreorder
+.global	__unmapself
+.type	__unmapself, @function
+__unmapself:
+	li	$2, 5011
+	syscall
+	li	$4, 0
+	li	$2, 5058
+	syscall
diff --git a/libc-top-half/musl/src/thread/mips64/clone.s b/libc-top-half/musl/src/thread/mips64/clone.s
new file mode 100644
index 0000000..2d86899
--- /dev/null
+++ b/libc-top-half/musl/src/thread/mips64/clone.s
@@ -0,0 +1,34 @@
+.set	noreorder
+.global	__clone
+.hidden __clone
+.type	__clone,@function
+__clone:
+	# Save function pointer and argument pointer on new thread stack
+	and	$5, $5, -16	# aligning stack to double word
+	dsubu	$5, $5, 16
+	sd	$4, 0($5)	# save function pointer
+	sd	$7, 8($5)	# save argument pointer
+
+	# Shuffle (fn,sp,fl,arg,ptid,tls,ctid) to (fl,sp,ptid,tls,ctid)
+	# sys_clone(u64 flags, u64 ustack_base, u64 parent_tidptr, u64 child_tidptr, u64 tls)
+	move	$4, $6
+	move	$6, $8
+	move	$7, $9
+	move	$8, $10
+	li	$2, 5055
+	syscall
+	beq	$7, $0, 1f
+	nop
+	jr	$ra
+	dsubu	$2, $0, $2
+1:	beq	$2, $0, 1f
+	nop
+	jr	$ra
+	nop
+1:	ld	$25, 0($sp)	# function pointer
+	ld	$4, 8($sp)	# argument pointer
+	jalr	$25		# call the user's function
+	nop
+	move 	$4, $2
+	li	$2, 5058
+	syscall
diff --git a/libc-top-half/musl/src/thread/mips64/syscall_cp.s b/libc-top-half/musl/src/thread/mips64/syscall_cp.s
new file mode 100644
index 0000000..0d4ede7
--- /dev/null
+++ b/libc-top-half/musl/src/thread/mips64/syscall_cp.s
@@ -0,0 +1,52 @@
+.set	noreorder
+.global	__cp_begin
+.hidden	__cp_begin
+.type	__cp_begin,@function
+.global	__cp_end
+.hidden	__cp_end
+.type	__cp_end,@function
+.global	__cp_cancel
+.hidden	__cp_cancel
+.type	__cp_cancel,@function
+.global	__cp_cancel_data
+.hidden	__cp_cancel_data
+.type	__cp_cancel_data,@function
+.hidden	__cancel
+.global	__syscall_cp_asm
+.hidden	__syscall_cp_asm
+.type	__syscall_cp_asm,@function
+__syscall_cp_asm:
+__cp_begin:
+	lw	$4, 0($4)
+	bne	$4, $0, __cp_cancel
+	move	$2, $5
+	move	$4, $6
+	move	$5, $7
+	move	$6, $8
+	move	$7, $9
+	move	$8, $10
+	move	$9, $11
+	ld	$10, 0($sp)
+	syscall
+__cp_end:
+	beq	$7, $0, 1f
+	nop
+	dsubu	$2, $0, $2
+1:	jr	$ra
+	nop
+
+	# if cancellation flag is 1 then call __cancel
+__cp_cancel:
+	move	$2, $ra
+.align 8
+	bal	1f
+	nop
+__cp_cancel_data:
+	.gpdword __cp_cancel_data
+	.gpdword __cancel
+1:	ld	$3, ($ra)
+	dsubu	$3, $ra, $3
+	ld	$25, 8($ra)
+	daddu	$25, $25, $3
+	jr	$25
+	move	$ra, $2
diff --git a/libc-top-half/musl/src/thread/mipsn32/__unmapself.s b/libc-top-half/musl/src/thread/mipsn32/__unmapself.s
new file mode 100644
index 0000000..4b032e5
--- /dev/null
+++ b/libc-top-half/musl/src/thread/mipsn32/__unmapself.s
@@ -0,0 +1,9 @@
+.set	noreorder
+.global	__unmapself
+.type	__unmapself,@function
+__unmapself:
+	li	$2, 6011
+	syscall
+	li	$4, 0
+	li	$2, 6058
+	syscall
diff --git a/libc-top-half/musl/src/thread/mipsn32/clone.s b/libc-top-half/musl/src/thread/mipsn32/clone.s
new file mode 100644
index 0000000..4d3c8c7
--- /dev/null
+++ b/libc-top-half/musl/src/thread/mipsn32/clone.s
@@ -0,0 +1,34 @@
+.set	noreorder
+.global	__clone
+.hidden __clone
+.type	__clone,@function
+__clone:
+	# Save function pointer and argument pointer on new thread stack
+	and	$5, $5, -16	# aligning stack to double word
+	subu	$5, $5, 16
+	sw	$4, 0($5)	# save function pointer
+	sw	$7, 4($5)	# save argument pointer
+
+	# Shuffle (fn,sp,fl,arg,ptid,tls,ctid) to (fl,sp,ptid,tls,ctid)
+	# sys_clone(u64 flags, u64 ustack_base, u64 parent_tidptr, u64 child_tidptr, u64 tls)
+	move	$4, $6
+	move	$6, $8
+	move	$7, $9
+	move	$8, $10
+	li	$2, 6055
+	syscall
+	beq	$7, $0, 1f
+	nop
+	jr	$ra
+	subu	$2, $0, $2
+1:	beq	$2, $0, 1f
+	nop
+	jr	$ra
+	nop
+1:	lw	$25, 0($sp)	# function pointer
+	lw	$4, 4($sp)	# argument pointer
+	jalr	$25		# call the user's function
+	nop
+	move 	$4, $2
+	li	$2, 6058
+	syscall
diff --git a/libc-top-half/musl/src/thread/mipsn32/syscall_cp.s b/libc-top-half/musl/src/thread/mipsn32/syscall_cp.s
new file mode 100644
index 0000000..e85615b
--- /dev/null
+++ b/libc-top-half/musl/src/thread/mipsn32/syscall_cp.s
@@ -0,0 +1,51 @@
+.set	noreorder
+.global	__cp_begin
+.hidden	__cp_begin
+.type	__cp_begin,@function
+.global	__cp_end
+.hidden	__cp_end
+.type	__cp_end,@function
+.global	__cp_cancel
+.hidden	__cp_cancel
+.type	__cp_cancel,@function
+.global	__cp_cancel_data
+.hidden	__cp_cancel_data
+.type	__cp_cancel_data,@function
+.hidden	__cancel
+.global	__syscall_cp_asm
+.hidden	__syscall_cp_asm
+.type	__syscall_cp_asm,@function
+__syscall_cp_asm:
+__cp_begin:
+	lw	$4, 0($4)
+	bne	$4, $0, __cp_cancel
+	move	$2, $5
+	move	$4, $6
+	move	$5, $7
+	move	$6, $8
+	move	$7, $9
+	move	$8, $10
+	move	$9, $11
+	lw	$10, 0($sp)
+	syscall
+__cp_end:
+	beq	$7, $0, 1f
+	nop
+	subu	$2, $0, $2
+1:	jr	$ra
+	nop
+
+	# if cancellation flag is 1 then call __cancel
+__cp_cancel:
+	move	$2, $ra
+	bal	1f
+	nop
+__cp_cancel_data:
+	.gpword __cp_cancel_data
+	.gpword __cancel
+1:	lw	$3, 0($ra)
+	subu	$3, $ra, $3
+	lw	$25, 4($ra)
+	addu	$25, $25, $3
+	jr	$25
+	move	$ra, $2
diff --git a/libc-top-half/musl/src/thread/mtx_destroy.c b/libc-top-half/musl/src/thread/mtx_destroy.c
new file mode 100644
index 0000000..40a0899
--- /dev/null
+++ b/libc-top-half/musl/src/thread/mtx_destroy.c
@@ -0,0 +1,5 @@
+#include <threads.h>
+
+void mtx_destroy(mtx_t *mtx)
+{
+}
diff --git a/libc-top-half/musl/src/thread/mtx_init.c b/libc-top-half/musl/src/thread/mtx_init.c
new file mode 100644
index 0000000..4826f76
--- /dev/null
+++ b/libc-top-half/musl/src/thread/mtx_init.c
@@ -0,0 +1,10 @@
+#include "pthread_impl.h"
+#include <threads.h>
+
+int mtx_init(mtx_t *m, int type)
+{
+	*m = (mtx_t){
+		._m_type = ((type&mtx_recursive) ? PTHREAD_MUTEX_RECURSIVE : PTHREAD_MUTEX_NORMAL),
+	};
+	return thrd_success;
+}
diff --git a/libc-top-half/musl/src/thread/mtx_lock.c b/libc-top-half/musl/src/thread/mtx_lock.c
new file mode 100644
index 0000000..5c2415c
--- /dev/null
+++ b/libc-top-half/musl/src/thread/mtx_lock.c
@@ -0,0 +1,12 @@
+#include "pthread_impl.h"
+#include <threads.h>
+
+int mtx_lock(mtx_t *m)
+{
+	if (m->_m_type == PTHREAD_MUTEX_NORMAL && !a_cas(&m->_m_lock, 0, EBUSY))
+		return thrd_success;
+	/* Calling mtx_timedlock with a null pointer is an extension.
+	 * It is convenient, here to avoid duplication of the logic
+	 * for return values. */
+	return mtx_timedlock(m, 0);
+}
diff --git a/libc-top-half/musl/src/thread/mtx_timedlock.c b/libc-top-half/musl/src/thread/mtx_timedlock.c
new file mode 100644
index 0000000..d22c8cf
--- /dev/null
+++ b/libc-top-half/musl/src/thread/mtx_timedlock.c
@@ -0,0 +1,13 @@
+#include <threads.h>
+#include <pthread.h>
+#include <errno.h>
+
+int mtx_timedlock(mtx_t *restrict m, const struct timespec *restrict ts)
+{
+	int ret = __pthread_mutex_timedlock((pthread_mutex_t *)m, ts);
+	switch (ret) {
+	default:        return thrd_error;
+	case 0:         return thrd_success;
+	case ETIMEDOUT: return thrd_timedout;
+	}
+}
diff --git a/libc-top-half/musl/src/thread/mtx_trylock.c b/libc-top-half/musl/src/thread/mtx_trylock.c
new file mode 100644
index 0000000..40a8b8c
--- /dev/null
+++ b/libc-top-half/musl/src/thread/mtx_trylock.c
@@ -0,0 +1,15 @@
+#include "pthread_impl.h"
+#include <threads.h>
+
+int mtx_trylock(mtx_t *m)
+{
+	if (m->_m_type == PTHREAD_MUTEX_NORMAL)
+		return (a_cas(&m->_m_lock, 0, EBUSY) & EBUSY) ? thrd_busy : thrd_success;
+
+	int ret = __pthread_mutex_trylock((pthread_mutex_t *)m);
+	switch (ret) {
+	default:    return thrd_error;
+	case 0:     return thrd_success;
+	case EBUSY: return thrd_busy;
+	}
+}
diff --git a/libc-top-half/musl/src/thread/mtx_unlock.c b/libc-top-half/musl/src/thread/mtx_unlock.c
new file mode 100644
index 0000000..2e5c8cf
--- /dev/null
+++ b/libc-top-half/musl/src/thread/mtx_unlock.c
@@ -0,0 +1,10 @@
+#include <threads.h>
+#include <pthread.h>
+
+int mtx_unlock(mtx_t *mtx)
+{
+	/* The only cases where pthread_mutex_unlock can return an
+	 * error are undefined behavior for C11 mtx_unlock, so we can
+	 * assume it does not return an error and simply tail call. */
+	return __pthread_mutex_unlock((pthread_mutex_t *)mtx);
+}
diff --git a/libc-top-half/musl/src/thread/or1k/__set_thread_area.s b/libc-top-half/musl/src/thread/or1k/__set_thread_area.s
new file mode 100644
index 0000000..b9ffb93
--- /dev/null
+++ b/libc-top-half/musl/src/thread/or1k/__set_thread_area.s
@@ -0,0 +1,7 @@
+.global __set_thread_area
+.hidden __set_thread_area
+.type   __set_thread_area,@function
+__set_thread_area:
+	l.ori	r10, r3, 0
+	l.jr	r9
+	 l.ori	r11, r0, 0
diff --git a/libc-top-half/musl/src/thread/or1k/__unmapself.s b/libc-top-half/musl/src/thread/or1k/__unmapself.s
new file mode 100644
index 0000000..6c0fa2a
--- /dev/null
+++ b/libc-top-half/musl/src/thread/or1k/__unmapself.s
@@ -0,0 +1,8 @@
+.global __unmapself
+.type   __unmapself,@function
+__unmapself:
+	l.ori	r11, r0, 215 /* __NR_munmap */
+	l.sys	1
+	l.ori	r3, r0, 0
+	l.ori	r11, r0, 93 /* __NR_exit */
+	l.sys	1
diff --git a/libc-top-half/musl/src/thread/or1k/clone.s b/libc-top-half/musl/src/thread/or1k/clone.s
new file mode 100644
index 0000000..2473ac2
--- /dev/null
+++ b/libc-top-half/musl/src/thread/or1k/clone.s
@@ -0,0 +1,31 @@
+/* int clone(fn, stack, flags, arg, ptid, tls, ctid)
+ *           r3  r4     r5     r6   sp+0  sp+4 sp+8
+ * sys_clone(flags, stack, ptid, ctid, tls)
+ */
+.global __clone
+.hidden __clone
+.type   __clone,@function
+__clone:
+	l.addi	r4, r4, -8
+	l.sw	0(r4), r3
+	l.sw	4(r4), r6
+	/* (fn, st, fl, ar, pt, tl, ct) => (fl, st, pt, ct, tl) */
+	l.ori	r3, r5, 0
+	l.lwz	r5, 0(r1)
+	l.lwz	r6, 8(r1)
+	l.lwz	r7, 4(r1)
+	l.ori	r11, r0, 220 /* __NR_clone */
+	l.sys	1
+
+	l.sfeqi	r11, 0
+	l.bf	1f
+	 l.nop
+	l.jr	r9
+	 l.nop
+
+1:	l.lwz	r11, 0(r1)
+	l.jalr	r11
+	 l.lwz	r3, 4(r1)
+
+	l.ori	r11, r0, 93 /* __NR_exit */
+	l.sys	1
diff --git a/libc-top-half/musl/src/thread/or1k/syscall_cp.s b/libc-top-half/musl/src/thread/or1k/syscall_cp.s
new file mode 100644
index 0000000..7951166
--- /dev/null
+++ b/libc-top-half/musl/src/thread/or1k/syscall_cp.s
@@ -0,0 +1,29 @@
+.global __cp_begin
+.hidden __cp_begin
+.global __cp_end
+.hidden __cp_end
+.global __cp_cancel
+.hidden __cp_cancel
+.hidden __cancel
+.global __syscall_cp_asm
+.hidden __syscall_cp_asm
+.type   __syscall_cp_asm,@function
+__syscall_cp_asm:
+__cp_begin:
+	l.lwz	r3, 0(r3)
+	l.sfeqi	r3, 0
+	l.bnf	__cp_cancel
+	 l.ori	r11, r4, 0
+	l.ori	r3, r5, 0
+	l.ori	r4, r6, 0
+	l.ori	r5, r7, 0
+	l.ori	r6, r8, 0
+	l.lwz	r7, 0(r1)
+	l.lwz	r8, 4(r1)
+	l.sys	1
+__cp_end:
+	l.jr	r9
+	 l.nop
+__cp_cancel:
+	l.j	__cancel
+	 l.nop
diff --git a/libc-top-half/musl/src/thread/powerpc/__set_thread_area.s b/libc-top-half/musl/src/thread/powerpc/__set_thread_area.s
new file mode 100644
index 0000000..86c498f
--- /dev/null
+++ b/libc-top-half/musl/src/thread/powerpc/__set_thread_area.s
@@ -0,0 +1,12 @@
+.text
+.global __set_thread_area
+.hidden __set_thread_area
+.type   __set_thread_area, %function
+__set_thread_area:
+	# mov pointer in reg3 into r2
+	mr 2, 3
+	# put 0 into return reg
+	li 3, 0
+	# return
+	blr
+
diff --git a/libc-top-half/musl/src/thread/powerpc/__unmapself.s b/libc-top-half/musl/src/thread/powerpc/__unmapself.s
new file mode 100644
index 0000000..c9360b4
--- /dev/null
+++ b/libc-top-half/musl/src/thread/powerpc/__unmapself.s
@@ -0,0 +1,9 @@
+	.text
+	.global __unmapself
+	.type   __unmapself,%function
+__unmapself:
+	li      0, 91 # __NR_munmap
+	sc
+	li      0, 1 #__NR_exit
+	sc
+	blr
diff --git a/libc-top-half/musl/src/thread/powerpc/clone.s b/libc-top-half/musl/src/thread/powerpc/clone.s
new file mode 100644
index 0000000..da13f44
--- /dev/null
+++ b/libc-top-half/musl/src/thread/powerpc/clone.s
@@ -0,0 +1,73 @@
+.text
+.global __clone
+.hidden __clone
+.type __clone, %function
+__clone:
+# int clone(fn, stack, flags, arg, ptid, tls, ctid)
+#            a  b       c     d     e    f    g
+#            3  4       5     6     7    8    9
+# pseudo C code:
+# tid = syscall(SYS_clone,c,b,e,f,g);
+# if (!tid) syscall(SYS_exit, a(d));
+# return tid;
+
+# SYS_clone = 120
+# SYS_exit = 1
+
+# store non-volatile regs r30, r31 on stack in order to put our
+# start func and its arg there
+stwu 30, -16(1)
+stw 31, 4(1)
+
+# save r3 (func) into r30, and r6(arg) into r31
+mr 30, 3
+mr 31, 6
+
+# create initial stack frame for new thread
+clrrwi 4, 4, 4
+li 0, 0
+stwu 0, -16(4)
+
+#move c into first arg
+mr 3, 5
+#mr 4, 4
+mr 5, 7
+mr 6, 8
+mr 7, 9
+
+# move syscall number into r0    
+li 0, 120
+
+sc
+
+# check for syscall error
+bns+ 1f # jump to label 1 if no summary overflow.
+#else
+neg 3, 3 #negate the result (errno)
+1:
+# compare sc result with 0
+cmpwi cr7, 3, 0
+
+# if not 0, jump to end
+bne cr7, 2f
+
+#else: we're the child
+#call funcptr: move arg (d) into r3
+mr 3, 31
+#move r30 (funcptr) into CTR reg
+mtctr 30
+# call CTR reg
+bctrl
+# mov SYS_exit into r0 (the exit param is already in r3)
+li 0, 1
+sc
+
+2:
+
+# restore stack
+lwz 30, 0(1)
+lwz 31, 4(1)
+addi 1, 1, 16
+
+blr
+
diff --git a/libc-top-half/musl/src/thread/powerpc/syscall_cp.s b/libc-top-half/musl/src/thread/powerpc/syscall_cp.s
new file mode 100644
index 0000000..77f8938
--- /dev/null
+++ b/libc-top-half/musl/src/thread/powerpc/syscall_cp.s
@@ -0,0 +1,59 @@
+.global __cp_begin
+.hidden __cp_begin
+.global __cp_end
+.hidden __cp_end
+.global __cp_cancel
+.hidden __cp_cancel
+.hidden __cancel
+.global __syscall_cp_asm
+.hidden __syscall_cp_asm
+
+#r0: volatile. may be modified during linkage.
+#r1: stack frame: 16 byte alignment.
+#r2: tls/thread pointer on pp32
+#r3,r4: return values, first args
+#r5-r10: args
+#r11-r12: volatile. may be modified during linkage
+#r13: "small data area" pointer
+#r14 - r30: local vars
+#r31: local or environment pointer
+
+#r1, r14-31: belong to the caller, must be saved and restored
+#r0, r3-r12, ctr, xer: volatile, not preserved
+#r0,r11,r12: may be altered by cross-module call, 
+#"a func cannot depend on that these regs have the values placed by the caller"
+
+#the fields CR2,CR2,CR4 of the cond reg must be preserved
+#LR (link reg) shall contain the funcs return address
+	.text
+	.type   __syscall_cp_asm,%function
+__syscall_cp_asm:
+	# at enter: r3 = pointer to self->cancel, r4: syscall no, r5: first arg, r6: 2nd, r7: 3rd, r8: 4th, r9: 5th, r10: 6th
+__cp_begin:
+	# r3 holds first argument, its a pointer to self->cancel. 
+	# we must compare the dereferenced value with 0 and jump to __cancel if its not
+	
+	lwz 0, 0(3) #deref pointer into r0
+	
+	cmpwi cr7, 0, 0 #compare r0 with 0, store result in cr7. 
+	beq+ cr7, 1f #jump to label 1 if r0 was 0
+	
+	b __cp_cancel #else call cancel
+1:
+	#ok, the cancel flag was not set
+	# syscall: number goes to r0, the rest 3-8
+	mr      0, 4                  # put the system call number into r0
+	mr      3, 5                  # Shift the arguments: arg1
+	mr      4, 6                  # arg2
+	mr      5, 7                  # arg3
+	mr      6, 8                  # arg4
+	mr      7, 9                  # arg5
+	mr      8, 10                  # arg6
+	sc
+__cp_end:
+	bnslr+ # return if no summary overflow. 
+	#else negate result.
+	neg 3, 3
+	blr
+__cp_cancel:
+	b __cancel
diff --git a/libc-top-half/musl/src/thread/powerpc64/__set_thread_area.s b/libc-top-half/musl/src/thread/powerpc64/__set_thread_area.s
new file mode 100644
index 0000000..bb9c55d
--- /dev/null
+++ b/libc-top-half/musl/src/thread/powerpc64/__set_thread_area.s
@@ -0,0 +1,9 @@
+.text
+.global __set_thread_area
+.hidden __set_thread_area
+.type   __set_thread_area, %function
+__set_thread_area:
+	mr 13, 3
+	li  3, 0
+	blr
+
diff --git a/libc-top-half/musl/src/thread/powerpc64/__unmapself.s b/libc-top-half/musl/src/thread/powerpc64/__unmapself.s
new file mode 100644
index 0000000..c9360b4
--- /dev/null
+++ b/libc-top-half/musl/src/thread/powerpc64/__unmapself.s
@@ -0,0 +1,9 @@
+	.text
+	.global __unmapself
+	.type   __unmapself,%function
+__unmapself:
+	li      0, 91 # __NR_munmap
+	sc
+	li      0, 1 #__NR_exit
+	sc
+	blr
diff --git a/libc-top-half/musl/src/thread/powerpc64/clone.s b/libc-top-half/musl/src/thread/powerpc64/clone.s
new file mode 100644
index 0000000..41cb678
--- /dev/null
+++ b/libc-top-half/musl/src/thread/powerpc64/clone.s
@@ -0,0 +1,48 @@
+.text
+.global __clone
+.hidden __clone
+.type __clone, %function
+__clone:
+	# int clone(fn, stack, flags, arg, ptid, tls, ctid)
+	#            a  b       c     d     e    f    g
+	#            3  4       5     6     7    8    9
+	# pseudo C code:
+	# tid = syscall(SYS_clone,c,b,e,f,g);
+	# if (!tid) syscall(SYS_exit, a(d));
+	# return tid;
+
+	# create initial stack frame for new thread
+	clrrdi 4, 4, 4
+	li     0, 0
+	stdu   0,-32(4)
+
+	# save fn and arg to child stack
+	std    3,  8(4)
+	std    6, 16(4)
+
+	# shuffle args into correct registers and call SYS_clone
+	mr    3, 5
+	#mr   4, 4
+	mr    5, 7
+	mr    6, 8
+	mr    7, 9
+	li    0, 120  # SYS_clone = 120
+	sc
+
+	# if error, negate return (errno)
+	bns+  1f
+	neg   3, 3
+
+1:	# if we're the parent, return
+	cmpwi cr7, 3, 0
+	bnelr cr7
+
+	# we're the child. call fn(arg)
+	ld     3, 16(1)
+	ld    12,  8(1)
+	mtctr 12
+	bctrl
+
+	# call SYS_exit. exit code is already in r3 from fn return value
+	li    0, 1    # SYS_exit = 1
+	sc
diff --git a/libc-top-half/musl/src/thread/powerpc64/syscall_cp.s b/libc-top-half/musl/src/thread/powerpc64/syscall_cp.s
new file mode 100644
index 0000000..ef50ed0
--- /dev/null
+++ b/libc-top-half/musl/src/thread/powerpc64/syscall_cp.s
@@ -0,0 +1,44 @@
+	.global __cp_begin
+	.hidden __cp_begin
+	.global __cp_end
+	.hidden __cp_end
+	.global __cp_cancel
+	.hidden __cp_cancel
+	.hidden __cancel
+	.global __syscall_cp_asm
+	.hidden __syscall_cp_asm
+	.text
+	.type   __syscall_cp_asm,%function
+__syscall_cp_asm:
+	# at enter: r3 = pointer to self->cancel, r4: syscall no, r5: first arg, r6: 2nd, r7: 3rd, r8: 4th, r9: 5th, r10: 6th
+__cp_begin:
+	# if (self->cancel) goto __cp_cancel
+	lwz   0, 0(3)
+	cmpwi cr7, 0, 0
+	bne-  cr7, __cp_cancel
+
+	# make syscall
+	mr    0,  4
+	mr    3,  5
+	mr    4,  6
+	mr    5,  7
+	mr    6,  8
+	mr    7,  9
+	mr    8, 10
+	sc
+
+__cp_end:
+	# return error ? -r3 : r3
+	bnslr+
+	neg 3, 3
+	blr
+
+__cp_cancel:
+	mflr 0
+	bl 1f
+	.long .TOC.-.
+1:	mflr 3
+	lwa 2, 0(3)
+	add 2, 2, 3
+	mtlr 0
+	b __cancel
diff --git a/libc-top-half/musl/src/thread/pthread_atfork.c b/libc-top-half/musl/src/thread/pthread_atfork.c
new file mode 100644
index 0000000..7649740
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_atfork.c
@@ -0,0 +1,49 @@
+#include <pthread.h>
+#include "libc.h"
+#include "lock.h"
+
+static struct atfork_funcs {
+	void (*prepare)(void);
+	void (*parent)(void);
+	void (*child)(void);
+	struct atfork_funcs *prev, *next;
+} *funcs;
+
+static volatile int lock[1];
+
+void __fork_handler(int who)
+{
+	struct atfork_funcs *p;
+	if (!funcs) return;
+	if (who < 0) {
+		LOCK(lock);
+		for (p=funcs; p; p = p->next) {
+			if (p->prepare) p->prepare();
+			funcs = p;
+		}
+	} else {
+		for (p=funcs; p; p = p->prev) {
+			if (!who && p->parent) p->parent();
+			else if (who && p->child) p->child();
+			funcs = p;
+		}
+		UNLOCK(lock);
+	}
+}
+
+int pthread_atfork(void (*prepare)(void), void (*parent)(void), void (*child)(void))
+{
+	struct atfork_funcs *new = malloc(sizeof *new);
+	if (!new) return -1;
+
+	LOCK(lock);
+	new->next = funcs;
+	new->prev = 0;
+	new->prepare = prepare;
+	new->parent = parent;
+	new->child = child;
+	if (funcs) funcs->prev = new;
+	funcs = new;
+	UNLOCK(lock);
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_attr_destroy.c b/libc-top-half/musl/src/thread/pthread_attr_destroy.c
new file mode 100644
index 0000000..b5845dd
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_attr_destroy.c
@@ -0,0 +1,6 @@
+#include "pthread_impl.h"
+
+int pthread_attr_destroy(pthread_attr_t *a)
+{
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_attr_get.c b/libc-top-half/musl/src/thread/pthread_attr_get.c
new file mode 100644
index 0000000..f12ff44
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_attr_get.c
@@ -0,0 +1,98 @@
+#include "pthread_impl.h"
+
+int pthread_attr_getdetachstate(const pthread_attr_t *a, int *state)
+{
+	*state = a->_a_detach;
+	return 0;
+}
+int pthread_attr_getguardsize(const pthread_attr_t *restrict a, size_t *restrict size)
+{
+	*size = a->_a_guardsize;
+	return 0;
+}
+
+int pthread_attr_getinheritsched(const pthread_attr_t *restrict a, int *restrict inherit)
+{
+	*inherit = a->_a_sched;
+	return 0;
+}
+
+int pthread_attr_getschedparam(const pthread_attr_t *restrict a, struct sched_param *restrict param)
+{
+	param->sched_priority = a->_a_prio;
+	return 0;
+}
+
+int pthread_attr_getschedpolicy(const pthread_attr_t *restrict a, int *restrict policy)
+{
+	*policy = a->_a_policy;
+	return 0;
+}
+
+int pthread_attr_getscope(const pthread_attr_t *restrict a, int *restrict scope)
+{
+	*scope = PTHREAD_SCOPE_SYSTEM;
+	return 0;
+}
+
+int pthread_attr_getstack(const pthread_attr_t *restrict a, void **restrict addr, size_t *restrict size)
+{
+	if (!a->_a_stackaddr)
+		return EINVAL;
+	*size = a->_a_stacksize;
+	*addr = (void *)(a->_a_stackaddr - *size);
+	return 0;
+}
+
+int pthread_attr_getstacksize(const pthread_attr_t *restrict a, size_t *restrict size)
+{
+	*size = a->_a_stacksize;
+	return 0;
+}
+
+int pthread_barrierattr_getpshared(const pthread_barrierattr_t *restrict a, int *restrict pshared)
+{
+	*pshared = !!a->__attr;
+	return 0;
+}
+
+int pthread_condattr_getclock(const pthread_condattr_t *restrict a, clockid_t *restrict clk)
+{
+	*clk = a->__attr & 0x7fffffff;
+	return 0;
+}
+
+int pthread_condattr_getpshared(const pthread_condattr_t *restrict a, int *restrict pshared)
+{
+	*pshared = a->__attr>>31;
+	return 0;
+}
+
+int pthread_mutexattr_getprotocol(const pthread_mutexattr_t *restrict a, int *restrict protocol)
+{
+	*protocol = a->__attr / 8U % 2;
+	return 0;
+}
+int pthread_mutexattr_getpshared(const pthread_mutexattr_t *restrict a, int *restrict pshared)
+{
+	*pshared = a->__attr / 128U % 2;
+	return 0;
+}
+
+int pthread_mutexattr_getrobust(const pthread_mutexattr_t *restrict a, int *restrict robust)
+{
+	*robust = a->__attr / 4U % 2;
+	return 0;
+}
+
+int pthread_mutexattr_gettype(const pthread_mutexattr_t *restrict a, int *restrict type)
+{
+	*type = a->__attr & 3;
+	return 0;
+}
+
+int pthread_rwlockattr_getpshared(const pthread_rwlockattr_t *restrict a, int *restrict pshared)
+{
+	*pshared = a->__attr[0];
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_attr_init.c b/libc-top-half/musl/src/thread/pthread_attr_init.c
new file mode 100644
index 0000000..463a8d2
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_attr_init.c
@@ -0,0 +1,11 @@
+#include "pthread_impl.h"
+
+int pthread_attr_init(pthread_attr_t *a)
+{
+	*a = (pthread_attr_t){0};
+	__acquire_ptc();
+	a->_a_stacksize = __default_stacksize;
+	a->_a_guardsize = __default_guardsize;
+	__release_ptc();
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_attr_setdetachstate.c b/libc-top-half/musl/src/thread/pthread_attr_setdetachstate.c
new file mode 100644
index 0000000..1b71278
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_attr_setdetachstate.c
@@ -0,0 +1,8 @@
+#include "pthread_impl.h"
+
+int pthread_attr_setdetachstate(pthread_attr_t *a, int state)
+{
+	if (state > 1U) return EINVAL;
+	a->_a_detach = state;
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_attr_setguardsize.c b/libc-top-half/musl/src/thread/pthread_attr_setguardsize.c
new file mode 100644
index 0000000..1c5c60a
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_attr_setguardsize.c
@@ -0,0 +1,8 @@
+#include "pthread_impl.h"
+
+int pthread_attr_setguardsize(pthread_attr_t *a, size_t size)
+{
+	if (size > SIZE_MAX/8) return EINVAL;
+	a->_a_guardsize = size;
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_attr_setinheritsched.c b/libc-top-half/musl/src/thread/pthread_attr_setinheritsched.c
new file mode 100644
index 0000000..ca264be
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_attr_setinheritsched.c
@@ -0,0 +1,9 @@
+#include "pthread_impl.h"
+#include "syscall.h"
+
+int pthread_attr_setinheritsched(pthread_attr_t *a, int inherit)
+{
+	if (inherit > 1U) return EINVAL;
+	a->_a_sched = inherit;
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_attr_setschedparam.c b/libc-top-half/musl/src/thread/pthread_attr_setschedparam.c
new file mode 100644
index 0000000..d4c1204
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_attr_setschedparam.c
@@ -0,0 +1,7 @@
+#include "pthread_impl.h"
+
+int pthread_attr_setschedparam(pthread_attr_t *restrict a, const struct sched_param *restrict param)
+{
+	a->_a_prio = param->sched_priority;
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_attr_setschedpolicy.c b/libc-top-half/musl/src/thread/pthread_attr_setschedpolicy.c
new file mode 100644
index 0000000..bb71f39
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_attr_setschedpolicy.c
@@ -0,0 +1,7 @@
+#include "pthread_impl.h"
+
+int pthread_attr_setschedpolicy(pthread_attr_t *a, int policy)
+{
+	a->_a_policy = policy;
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_attr_setscope.c b/libc-top-half/musl/src/thread/pthread_attr_setscope.c
new file mode 100644
index 0000000..46b520c
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_attr_setscope.c
@@ -0,0 +1,13 @@
+#include "pthread_impl.h"
+
+int pthread_attr_setscope(pthread_attr_t *a, int scope)
+{
+	switch (scope) {
+	case PTHREAD_SCOPE_SYSTEM:
+		return 0;
+	case PTHREAD_SCOPE_PROCESS:
+		return ENOTSUP;
+	default:
+		return EINVAL;
+	}
+}
diff --git a/libc-top-half/musl/src/thread/pthread_attr_setstack.c b/libc-top-half/musl/src/thread/pthread_attr_setstack.c
new file mode 100644
index 0000000..1eddcbd
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_attr_setstack.c
@@ -0,0 +1,9 @@
+#include "pthread_impl.h"
+
+int pthread_attr_setstack(pthread_attr_t *a, void *addr, size_t size)
+{
+	if (size-PTHREAD_STACK_MIN > SIZE_MAX/4) return EINVAL;
+	a->_a_stackaddr = (size_t)addr + size;
+	a->_a_stacksize = size;
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_attr_setstacksize.c b/libc-top-half/musl/src/thread/pthread_attr_setstacksize.c
new file mode 100644
index 0000000..9c6a880
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_attr_setstacksize.c
@@ -0,0 +1,9 @@
+#include "pthread_impl.h"
+
+int pthread_attr_setstacksize(pthread_attr_t *a, size_t size)
+{
+	if (size-PTHREAD_STACK_MIN > SIZE_MAX/4) return EINVAL;
+	a->_a_stackaddr = 0;
+	a->_a_stacksize = size;
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_barrier_destroy.c b/libc-top-half/musl/src/thread/pthread_barrier_destroy.c
new file mode 100644
index 0000000..4ce0b2e
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_barrier_destroy.c
@@ -0,0 +1,15 @@
+#include "pthread_impl.h"
+
+int pthread_barrier_destroy(pthread_barrier_t *b)
+{
+	if (b->_b_limit < 0) {
+		if (b->_b_lock) {
+			int v;
+			a_or(&b->_b_lock, INT_MIN);
+			while ((v = b->_b_lock) & INT_MAX)
+				__wait(&b->_b_lock, 0, v, 0);
+		}
+		__vm_wait();
+	}
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_barrier_init.c b/libc-top-half/musl/src/thread/pthread_barrier_init.c
new file mode 100644
index 0000000..4c3cb28
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_barrier_init.c
@@ -0,0 +1,8 @@
+#include "pthread_impl.h"
+
+int pthread_barrier_init(pthread_barrier_t *restrict b, const pthread_barrierattr_t *restrict a, unsigned count)
+{
+	if (count-1 > INT_MAX-1) return EINVAL;
+	*b = (pthread_barrier_t){ ._b_limit = count-1 | (a?a->__attr:0) };
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_barrier_wait.c b/libc-top-half/musl/src/thread/pthread_barrier_wait.c
new file mode 100644
index 0000000..cc2a8bb
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_barrier_wait.c
@@ -0,0 +1,111 @@
+#include "pthread_impl.h"
+
+static int pshared_barrier_wait(pthread_barrier_t *b)
+{
+	int limit = (b->_b_limit & INT_MAX) + 1;
+	int ret = 0;
+	int v, w;
+
+	if (limit==1) return PTHREAD_BARRIER_SERIAL_THREAD;
+
+	while ((v=a_cas(&b->_b_lock, 0, limit)))
+		__wait(&b->_b_lock, &b->_b_waiters, v, 0);
+
+	/* Wait for <limit> threads to get to the barrier */
+	if (++b->_b_count == limit) {
+		a_store(&b->_b_count, 0);
+		ret = PTHREAD_BARRIER_SERIAL_THREAD;
+		if (b->_b_waiters2) __wake(&b->_b_count, -1, 0);
+	} else {
+		a_store(&b->_b_lock, 0);
+		if (b->_b_waiters) __wake(&b->_b_lock, 1, 0);
+		while ((v=b->_b_count)>0)
+			__wait(&b->_b_count, &b->_b_waiters2, v, 0);
+	}
+
+	__vm_lock();
+
+	/* Ensure all threads have a vm lock before proceeding */
+	if (a_fetch_add(&b->_b_count, -1)==1-limit) {
+		a_store(&b->_b_count, 0);
+		if (b->_b_waiters2) __wake(&b->_b_count, -1, 0);
+	} else {
+		while ((v=b->_b_count))
+			__wait(&b->_b_count, &b->_b_waiters2, v, 0);
+	}
+	
+	/* Perform a recursive unlock suitable for self-sync'd destruction */
+	do {
+		v = b->_b_lock;
+		w = b->_b_waiters;
+	} while (a_cas(&b->_b_lock, v, v==INT_MIN+1 ? 0 : v-1) != v);
+
+	/* Wake a thread waiting to reuse or destroy the barrier */
+	if (v==INT_MIN+1 || (v==1 && w))
+		__wake(&b->_b_lock, 1, 0);
+
+	__vm_unlock();
+
+	return ret;
+}
+
+struct instance
+{
+	volatile int count;
+	volatile int last;
+	volatile int waiters;
+	volatile int finished;
+};
+
+int pthread_barrier_wait(pthread_barrier_t *b)
+{
+	int limit = b->_b_limit;
+	struct instance *inst;
+
+	/* Trivial case: count was set at 1 */
+	if (!limit) return PTHREAD_BARRIER_SERIAL_THREAD;
+
+	/* Process-shared barriers require a separate, inefficient wait */
+	if (limit < 0) return pshared_barrier_wait(b);
+
+	/* Otherwise we need a lock on the barrier object */
+	while (a_swap(&b->_b_lock, 1))
+		__wait(&b->_b_lock, &b->_b_waiters, 1, 1);
+	inst = b->_b_inst;
+
+	/* First thread to enter the barrier becomes the "instance owner" */
+	if (!inst) {
+		struct instance new_inst = { 0 };
+		int spins = 200;
+		b->_b_inst = inst = &new_inst;
+		a_store(&b->_b_lock, 0);
+		if (b->_b_waiters) __wake(&b->_b_lock, 1, 1);
+		while (spins-- && !inst->finished)
+			a_spin();
+		a_inc(&inst->finished);
+		while (inst->finished == 1)
+			__syscall(SYS_futex,&inst->finished,FUTEX_WAIT|FUTEX_PRIVATE,1,0) != -ENOSYS
+			|| __syscall(SYS_futex,&inst->finished,FUTEX_WAIT,1,0);
+		return PTHREAD_BARRIER_SERIAL_THREAD;
+	}
+
+	/* Last thread to enter the barrier wakes all non-instance-owners */
+	if (++inst->count == limit) {
+		b->_b_inst = 0;
+		a_store(&b->_b_lock, 0);
+		if (b->_b_waiters) __wake(&b->_b_lock, 1, 1);
+		a_store(&inst->last, 1);
+		if (inst->waiters)
+			__wake(&inst->last, -1, 1);
+	} else {
+		a_store(&b->_b_lock, 0);
+		if (b->_b_waiters) __wake(&b->_b_lock, 1, 1);
+		__wait(&inst->last, &inst->waiters, 0, 1);
+	}
+
+	/* Last thread to exit the barrier wakes the instance owner */
+	if (a_fetch_add(&inst->count,-1)==1 && a_fetch_add(&inst->finished,1))
+		__wake(&inst->finished, 1, 1);
+
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_barrierattr_destroy.c b/libc-top-half/musl/src/thread/pthread_barrierattr_destroy.c
new file mode 100644
index 0000000..adec738
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_barrierattr_destroy.c
@@ -0,0 +1,6 @@
+#include "pthread_impl.h"
+
+int pthread_barrierattr_destroy(pthread_barrierattr_t *a)
+{
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_barrierattr_init.c b/libc-top-half/musl/src/thread/pthread_barrierattr_init.c
new file mode 100644
index 0000000..fa742bb
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_barrierattr_init.c
@@ -0,0 +1,7 @@
+#include "pthread_impl.h"
+
+int pthread_barrierattr_init(pthread_barrierattr_t *a)
+{
+	*a = (pthread_barrierattr_t){0};
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_barrierattr_setpshared.c b/libc-top-half/musl/src/thread/pthread_barrierattr_setpshared.c
new file mode 100644
index 0000000..c2d2929
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_barrierattr_setpshared.c
@@ -0,0 +1,8 @@
+#include "pthread_impl.h"
+
+int pthread_barrierattr_setpshared(pthread_barrierattr_t *a, int pshared)
+{
+	if (pshared > 1U) return EINVAL;
+	a->__attr = pshared ? INT_MIN : 0;
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_cancel.c b/libc-top-half/musl/src/thread/pthread_cancel.c
new file mode 100644
index 0000000..2f9d5e9
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_cancel.c
@@ -0,0 +1,101 @@
+#define _GNU_SOURCE
+#include <string.h>
+#include "pthread_impl.h"
+#include "syscall.h"
+
+hidden long __cancel(), __syscall_cp_asm(), __syscall_cp_c();
+
+long __cancel()
+{
+	pthread_t self = __pthread_self();
+	if (self->canceldisable == PTHREAD_CANCEL_ENABLE || self->cancelasync)
+		pthread_exit(PTHREAD_CANCELED);
+	self->canceldisable = PTHREAD_CANCEL_DISABLE;
+	return -ECANCELED;
+}
+
+long __syscall_cp_asm(volatile void *, syscall_arg_t,
+                      syscall_arg_t, syscall_arg_t, syscall_arg_t,
+                      syscall_arg_t, syscall_arg_t, syscall_arg_t);
+
+long __syscall_cp_c(syscall_arg_t nr,
+                    syscall_arg_t u, syscall_arg_t v, syscall_arg_t w,
+                    syscall_arg_t x, syscall_arg_t y, syscall_arg_t z)
+{
+	pthread_t self;
+	long r;
+	int st;
+
+	if ((st=(self=__pthread_self())->canceldisable)
+	    && (st==PTHREAD_CANCEL_DISABLE || nr==SYS_close))
+		return __syscall(nr, u, v, w, x, y, z);
+
+	r = __syscall_cp_asm(&self->cancel, nr, u, v, w, x, y, z);
+	if (r==-EINTR && nr!=SYS_close && self->cancel &&
+	    self->canceldisable != PTHREAD_CANCEL_DISABLE)
+		r = __cancel();
+	return r;
+}
+
+static void _sigaddset(sigset_t *set, int sig)
+{
+	unsigned s = sig-1;
+	set->__bits[s/8/sizeof *set->__bits] |= 1UL<<(s&8*sizeof *set->__bits-1);
+}
+
+extern hidden const char __cp_begin[1], __cp_end[1], __cp_cancel[1];
+
+static void cancel_handler(int sig, siginfo_t *si, void *ctx)
+{
+	pthread_t self = __pthread_self();
+	ucontext_t *uc = ctx;
+	uintptr_t pc = uc->uc_mcontext.MC_PC;
+
+	a_barrier();
+	if (!self->cancel || self->canceldisable == PTHREAD_CANCEL_DISABLE) return;
+
+	_sigaddset(&uc->uc_sigmask, SIGCANCEL);
+
+	if (self->cancelasync || pc >= (uintptr_t)__cp_begin && pc < (uintptr_t)__cp_end) {
+		uc->uc_mcontext.MC_PC = (uintptr_t)__cp_cancel;
+#ifdef CANCEL_GOT
+		uc->uc_mcontext.MC_GOT = CANCEL_GOT;
+#endif
+		return;
+	}
+
+	__syscall(SYS_tkill, self->tid, SIGCANCEL);
+}
+
+void __testcancel()
+{
+	pthread_t self = __pthread_self();
+	if (self->cancel && !self->canceldisable)
+		__cancel();
+}
+
+static void init_cancellation()
+{
+	struct sigaction sa = {
+		.sa_flags = SA_SIGINFO | SA_RESTART,
+		.sa_sigaction = cancel_handler
+	};
+	memset(&sa.sa_mask, -1, _NSIG/8);
+	__libc_sigaction(SIGCANCEL, &sa, 0);
+}
+
+int pthread_cancel(pthread_t t)
+{
+	static int init;
+	if (!init) {
+		init_cancellation();
+		init = 1;
+	}
+	a_store(&t->cancel, 1);
+	if (t == pthread_self()) {
+		if (t->canceldisable == PTHREAD_CANCEL_ENABLE && t->cancelasync)
+			pthread_exit(PTHREAD_CANCELED);
+		return 0;
+	}
+	return pthread_kill(t, SIGCANCEL);
+}
diff --git a/libc-top-half/musl/src/thread/pthread_cleanup_push.c b/libc-top-half/musl/src/thread/pthread_cleanup_push.c
new file mode 100644
index 0000000..9b21764
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_cleanup_push.c
@@ -0,0 +1,20 @@
+#include "pthread_impl.h"
+
+static void dummy(struct __ptcb *cb)
+{
+}
+weak_alias(dummy, __do_cleanup_push);
+weak_alias(dummy, __do_cleanup_pop);
+
+void _pthread_cleanup_push(struct __ptcb *cb, void (*f)(void *), void *x)
+{
+	cb->__f = f;
+	cb->__x = x;
+	__do_cleanup_push(cb);
+}
+
+void _pthread_cleanup_pop(struct __ptcb *cb, int run)
+{
+	__do_cleanup_pop(cb);
+	if (run) cb->__f(cb->__x);
+}
diff --git a/libc-top-half/musl/src/thread/pthread_cond_broadcast.c b/libc-top-half/musl/src/thread/pthread_cond_broadcast.c
new file mode 100644
index 0000000..6bfab78
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_cond_broadcast.c
@@ -0,0 +1,10 @@
+#include "pthread_impl.h"
+
+int pthread_cond_broadcast(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);
+	__wake(&c->_c_seq, -1, 0);
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_cond_destroy.c b/libc-top-half/musl/src/thread/pthread_cond_destroy.c
new file mode 100644
index 0000000..8c55516
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_cond_destroy.c
@@ -0,0 +1,14 @@
+#include "pthread_impl.h"
+
+int pthread_cond_destroy(pthread_cond_t *c)
+{
+	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/libc-top-half/musl/src/thread/pthread_cond_init.c b/libc-top-half/musl/src/thread/pthread_cond_init.c
new file mode 100644
index 0000000..8c484dd
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_cond_init.c
@@ -0,0 +1,11 @@
+#include "pthread_impl.h"
+
+int pthread_cond_init(pthread_cond_t *restrict c, const pthread_condattr_t *restrict a)
+{
+	*c = (pthread_cond_t){0};
+	if (a) {
+		c->_c_clock = a->__attr & 0x7fffffff;
+		if (a->__attr>>31) c->_c_shared = (void *)-1;
+	}
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_cond_signal.c b/libc-top-half/musl/src/thread/pthread_cond_signal.c
new file mode 100644
index 0000000..575ad54
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_cond_signal.c
@@ -0,0 +1,10 @@
+#include "pthread_impl.h"
+
+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);
+	__wake(&c->_c_seq, 1, 0);
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_cond_timedwait.c b/libc-top-half/musl/src/thread/pthread_cond_timedwait.c
new file mode 100644
index 0000000..ba985f9
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_cond_timedwait.c
@@ -0,0 +1,230 @@
+#include "pthread_impl.h"
+
+#ifndef __wasilibc_unmodified_upstream
+#include <common/clock.h>
+#endif
+
+/*
+ * 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;
+	volatile int state, barrier;
+	volatile int *notify;
+};
+
+/* Self-synchronized-destruction-safe lock functions */
+
+static inline void lock(volatile int *l)
+{
+	if (a_cas(l, 0, 1)) {
+		a_cas(l, 1, 2);
+		do __wait(l, 0, 2, 1);
+		while (a_cas(l, 0, 2));
+	}
+}
+
+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);
+#ifdef __wasilibc_unmodified_upstream
+	if (w) __wake(l, 1, 1);
+	else __syscall(SYS_futex, l, FUTEX_REQUEUE|FUTEX_PRIVATE, 0, 1, r) != -ENOSYS
+		|| __syscall(SYS_futex, l, FUTEX_REQUEUE, 0, 1, r);
+#else
+	// Always wake due to lack of requeue system call in WASI
+	// This can impact the performance, so we might need to re-visit that decision
+	__wake(l, 1, 1);
+#endif
+}
+
+enum {
+	WAITING,
+	SIGNALED,
+	LEAVING,
+};
+
+int __pthread_cond_timedwait(pthread_cond_t *restrict c, pthread_mutex_t *restrict m, const struct timespec *restrict ts)
+{
+	struct waiter node = { 0 };
+	int e, seq, clock = c->_c_clock, cs, shared=0, oldstate, tmp;
+#ifndef __wasilibc_unmodified_upstream
+	struct __clockid clock_id = { .id = clock };
+#endif
+	volatile int *fut;
+
+	if ((m->_m_type&15) && (m->_m_lock&INT_MAX) != __pthread_self()->tid)
+		return EPERM;
+
+	if (ts && ts->tv_nsec >= 1000000000UL)
+		return EINVAL;
+
+	__pthread_testcancel();
+
+	if (c->_c_shared) {
+		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);
+	}
+
+	__pthread_mutex_unlock(m);
+
+	__pthread_setcancelstate(PTHREAD_CANCEL_MASKED, &cs);
+	if (cs == PTHREAD_CANCEL_DISABLE) __pthread_setcancelstate(cs, 0);
+
+#ifdef __wasilibc_unmodified_upstream
+	do e = __timedwait_cp(fut, seq, clock, ts, !shared);
+#else
+	do e = __timedwait_cp(fut, seq, &clock_id, ts, !shared);
+#endif
+	while (*fut==seq && (!e || e==EINTR));
+	if (e == EINTR) e = 0;
+
+	if (shared) {
+		/* Suppress cancellation if a signal was potentially
+		 * consumed; this is a legitimate form of spurious
+		 * wake even if not. */
+		if (e == ECANCELED && c->_c_seq != seq) e = 0;
+		if (a_fetch_add(&c->_c_waiters, -1) == -0x7fffffff)
+			__wake(&c->_c_waiters, 1, 0);
+		oldstate = WAITING;
+		goto relock;
+	}
+
+	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. */
+
+		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);
+	}
+
+relock:
+	/* Errors locking the mutex override any existing error or
+	 * cancellation, since the caller must see them to know the
+	 * state of the mutex. */
+	if ((tmp = pthread_mutex_lock(m))) e = tmp;
+
+	if (oldstate == WAITING) goto done;
+
+	if (!node.next && !(m->_m_type & 8))
+		a_inc(&m->_m_waiters);
+
+	/* Unlock the barrier that's holding back the next waiter, and
+	 * either wake it or requeue it to the mutex. */
+	if (node.prev) {
+		int val = m->_m_lock;
+		if (val>0) a_cas(&m->_m_lock, val, val|0x80000000);
+		unlock_requeue(&node.prev->barrier, &m->_m_lock, m->_m_type & (8|128));
+	} else if (!(m->_m_type & 8)) {
+		a_dec(&m->_m_waiters);		
+	}
+
+	/* Since a signal was consumed, cancellation is not permitted. */
+	if (e == ECANCELED) e = 0;
+
+done:
+	__pthread_setcancelstate(cs, 0);
+
+	if (e == ECANCELED) {
+		__pthread_testcancel();
+		__pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, 0);
+	}
+
+	return e;
+}
+
+int __private_cond_signal(pthread_cond_t *c, int n)
+{
+	struct waiter *p, *first=0;
+	volatile int ref = 0;
+	int 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);
+
+	/* Allow first signaled waiter, if any, to proceed. */
+	if (first) unlock(&first->barrier);
+
+	return 0;
+}
+
+weak_alias(__pthread_cond_timedwait, pthread_cond_timedwait);
diff --git a/libc-top-half/musl/src/thread/pthread_cond_wait.c b/libc-top-half/musl/src/thread/pthread_cond_wait.c
new file mode 100644
index 0000000..8735bf1
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_cond_wait.c
@@ -0,0 +1,6 @@
+#include "pthread_impl.h"
+
+int pthread_cond_wait(pthread_cond_t *restrict c, pthread_mutex_t *restrict m)
+{
+	return pthread_cond_timedwait(c, m, 0);
+}
diff --git a/libc-top-half/musl/src/thread/pthread_condattr_destroy.c b/libc-top-half/musl/src/thread/pthread_condattr_destroy.c
new file mode 100644
index 0000000..c54ec41
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_condattr_destroy.c
@@ -0,0 +1,6 @@
+#include "pthread_impl.h"
+
+int pthread_condattr_destroy(pthread_condattr_t *a)
+{
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_condattr_init.c b/libc-top-half/musl/src/thread/pthread_condattr_init.c
new file mode 100644
index 0000000..a41741b
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_condattr_init.c
@@ -0,0 +1,7 @@
+#include "pthread_impl.h"
+
+int pthread_condattr_init(pthread_condattr_t *a)
+{
+	*a = (pthread_condattr_t){0};
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_condattr_setclock.c b/libc-top-half/musl/src/thread/pthread_condattr_setclock.c
new file mode 100644
index 0000000..21ca070
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_condattr_setclock.c
@@ -0,0 +1,21 @@
+#include "pthread_impl.h"
+
+#ifndef __wasilibc_unmodified_upstream
+#include <common/clock.h>
+#endif
+
+int pthread_condattr_setclock(pthread_condattr_t *a, clockid_t clk)
+{
+#ifdef __wasilibc_unmodified_upstream
+	if (clk < 0 || clk-2U < 2) return EINVAL;
+#else
+	if (clk->id < 0 || clk->id-2U < 2) return EINVAL;
+#endif
+	a->__attr &= 0x80000000;
+#ifdef __wasilibc_unmodified_upstream
+	a->__attr |= clk;
+#else
+	a->__attr |= clk->id;
+#endif
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_condattr_setpshared.c b/libc-top-half/musl/src/thread/pthread_condattr_setpshared.c
new file mode 100644
index 0000000..51453e0
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_condattr_setpshared.c
@@ -0,0 +1,9 @@
+#include "pthread_impl.h"
+
+int pthread_condattr_setpshared(pthread_condattr_t *a, int pshared)
+{
+	if (pshared > 1U) return EINVAL;
+	a->__attr &= 0x7fffffff;
+	a->__attr |= (unsigned)pshared<<31;
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_create.c b/libc-top-half/musl/src/thread/pthread_create.c
new file mode 100644
index 0000000..1aa7be7
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_create.c
@@ -0,0 +1,565 @@
+#define _GNU_SOURCE
+#include "pthread_impl.h"
+#include "stdio_impl.h"
+#include "libc.h"
+#include "lock.h"
+#ifdef __wasilibc_unmodified_upstream
+#include <sys/mman.h>
+#endif
+#include <string.h>
+#include <stddef.h>
+#ifndef __wasilibc_unmodified_upstream
+#include <stdatomic.h>
+#endif
+
+#include <stdalign.h>
+
+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_orphaned_stdio_locks);
+#ifdef __wasilibc_unmodified_upstream
+weak_alias(dummy_0, __dl_thread_cleanup);
+weak_alias(dummy_0, __membarrier_init);
+#endif
+
+static int tl_lock_count;
+static int tl_lock_waiters;
+
+void __tl_lock(void)
+{
+	int tid = __pthread_self()->tid;
+	int val = __thread_list_lock;
+	if (val == tid) {
+		tl_lock_count++;
+		return;
+	}
+	while ((val = a_cas(&__thread_list_lock, 0, tid)))
+		__wait(&__thread_list_lock, &tl_lock_waiters, val, 0);
+}
+
+void __tl_unlock(void)
+{
+	if (tl_lock_count) {
+		tl_lock_count--;
+		return;
+	}
+	a_store(&__thread_list_lock, 0);
+	if (tl_lock_waiters) __wake(&__thread_list_lock, 1, 0);
+}
+
+void __tl_sync(pthread_t td)
+{
+	a_barrier();
+	int val = __thread_list_lock;
+	if (!val) return;
+	__wait(&__thread_list_lock, &tl_lock_waiters, val, 0);
+	if (tl_lock_waiters) __wake(&__thread_list_lock, 1, 0);
+}
+
+_Noreturn void __pthread_exit(void *result)
+{
+	pthread_t self = __pthread_self();
+	sigset_t set;
+
+	self->canceldisable = 1;
+	self->cancelasync = 0;
+	self->result = result;
+
+	while (self->cancelbuf) {
+		void (*f)(void *) = self->cancelbuf->__f;
+		void *x = self->cancelbuf->__x;
+		self->cancelbuf = self->cancelbuf->__next;
+		f(x);
+	}
+
+	__pthread_tsd_run_dtors();
+
+#ifdef __wasilibc_unmodified_upstream
+	__block_app_sigs(&set);
+#endif
+
+	/* This atomic potentially competes with a concurrent pthread_detach
+	 * call; the loser is responsible for freeing thread resources. */
+	int state = a_cas(&self->detach_state, DT_JOINABLE, DT_EXITING);
+
+	if (state==DT_DETACHED && self->map_base) {
+		/* Since __unmapself bypasses the normal munmap code path,
+		 * explicitly wait for vmlock holders first. This must be
+		 * done before any locks are taken, to avoid lock ordering
+		 * issues that could lead to deadlock. */
+#ifdef __wasilibc_unmodified_upstream
+		__vm_wait();
+#endif
+	}
+
+	/* Access to target the exiting thread with syscalls that use
+	 * its kernel tid is controlled by killlock. For detached threads,
+	 * any use past this point would have undefined behavior, but for
+	 * joinable threads it's a valid usage that must be handled.
+	 * Signals must be blocked since pthread_kill must be AS-safe. */
+	LOCK(self->killlock);
+
+	/* The thread list lock must be AS-safe, and thus depends on
+	 * application signals being blocked above. */
+	__tl_lock();
+
+	/* If this is the only thread in the list, don't proceed with
+	 * termination of the thread, but restore the previous lock and
+	 * signal state to prepare for exit to call atexit handlers. */
+	if (self->next == self) {
+		__tl_unlock();
+		UNLOCK(self->killlock);
+		self->detach_state = state;
+#ifdef __wasilibc_unmodified_upstream
+		__restore_sigs(&set);
+#endif
+		exit(0);
+	}
+
+	/* At this point we are committed to thread termination. */
+
+#ifdef __wasilibc_unmodified_upstream
+	/* Process robust list in userspace to handle non-pshared mutexes
+	 * and the detached thread case where the robust list head will
+	 * be invalid when the kernel would process it. */
+	__vm_lock();
+#endif
+	volatile void *volatile *rp;
+	while ((rp=self->robust_list.head) && rp != &self->robust_list.head) {
+		pthread_mutex_t *m = (void *)((char *)rp
+			- offsetof(pthread_mutex_t, _m_next));
+		int waiters = m->_m_waiters;
+		int priv = (m->_m_type & 128) ^ 128;
+		self->robust_list.pending = rp;
+		self->robust_list.head = *rp;
+		int cont = a_swap(&m->_m_lock, 0x40000000);
+		self->robust_list.pending = 0;
+		if (cont < 0 || waiters)
+			__wake(&m->_m_lock, 1, priv);
+	}
+#ifdef __wasilibc_unmodified_upstream
+	__vm_unlock();
+#endif
+
+	__do_orphaned_stdio_locks();
+#ifdef __wasilibc_unmodified_upstream
+	__dl_thread_cleanup();
+#endif
+
+	/* Last, unlink thread from the list. This change will not be visible
+	 * until the lock is released, which only happens after SYS_exit
+	 * has been called, via the exit futex address pointing at the lock.
+	 * This needs to happen after any possible calls to LOCK() that might
+	 * skip locking if process appears single-threaded. */
+	if (!--libc.threads_minus_1) libc.need_locks = -1;
+	self->next->prev = self->prev;
+	self->prev->next = self->next;
+	self->prev = self->next = self;
+
+#ifndef __wasilibc_unmodified_upstream
+	/* On Linux, the thread is created with CLONE_CHILD_CLEARTID,
+	 * and this lock will unlock by kernel when this thread terminates.
+	 * So we should unlock it here in WebAssembly.
+	 * See also set_tid_address(2) */
+	__tl_unlock();
+#endif
+
+#ifdef __wasilibc_unmodified_upstream
+	if (state==DT_DETACHED && self->map_base) {
+		/* Detached threads must block even implementation-internal
+		 * signals, since they will not have a stack in their last
+		 * moments of existence. */
+		__block_all_sigs(&set);
+
+		/* Robust list will no longer be valid, and was already
+		 * processed above, so unregister it with the kernel. */
+		if (self->robust_list.off)
+			__syscall(SYS_set_robust_list, 0, 3*sizeof(long));
+
+		/* The following call unmaps the thread's stack mapping
+		 * and then exits without touching the stack. */
+		__unmapself(self->map_base, self->map_size);
+	}
+#else
+	if (state==DT_DETACHED && self->map_base) {
+		// __syscall(SYS_exit) would unlock the thread, list
+		// do it manually here
+		__tl_unlock();
+		free(self->map_base);
+		// Can't use `exit()` here, because it is too high level
+		for (;;) __wasi_proc_exit(0);
+	}
+#endif
+
+	/* Wake any joiner. */
+	a_store(&self->detach_state, DT_EXITED);
+	__wake(&self->detach_state, 1, 1);
+
+	/* After the kernel thread exits, its tid may be reused. Clear it
+	 * to prevent inadvertent use and inform functions that would use
+	 * it that it's no longer available. */
+	self->tid = 0;
+	UNLOCK(self->killlock);
+
+#ifdef __wasilibc_unmodified_upstream
+	for (;;) __syscall(SYS_exit, 0);
+#else
+	// __syscall(SYS_exit) would unlock the thread, list
+	// do it manually here
+	__tl_unlock();
+	// Can't use `exit()` here, because it is too high level
+	for (;;) __wasi_proc_exit(0);
+#endif
+}
+
+void __do_cleanup_push(struct __ptcb *cb)
+{
+	struct pthread *self = __pthread_self();
+	cb->__next = self->cancelbuf;
+	self->cancelbuf = cb;
+}
+
+void __do_cleanup_pop(struct __ptcb *cb)
+{
+	__pthread_self()->cancelbuf = cb->__next;
+}
+
+struct start_args {
+#ifdef __wasilibc_unmodified_upstream
+	void *(*start_func)(void *);
+	void *start_arg;
+	volatile int control;
+	unsigned long sig_mask[_NSIG/8/sizeof(long)];
+#else
+	void *(*start_func)(void *);
+	void *start_arg;
+	void *tls_base;
+#endif
+};
+
+#ifdef __wasilibc_unmodified_upstream
+static int start(void *p)
+{
+	struct start_args *args = p;
+	int state = args->control;
+	if (state) {
+		if (a_cas(&args->control, 1, 2)==1)
+			__wait(&args->control, 0, 2, 1);
+		if (args->control) {
+#ifdef __wasilibc_unmodified_upstream
+			__syscall(SYS_set_tid_address, &args->control);
+			for (;;) __syscall(SYS_exit, 0);
+#endif
+		}
+	}
+#ifdef __wasilibc_unmodified_upstream
+	__syscall(SYS_rt_sigprocmask, SIG_SETMASK, &args->sig_mask, 0, _NSIG/8);
+#endif
+	__pthread_exit(args->start_func(args->start_arg));
+	return 0;
+}
+
+static int start_c11(void *p)
+{
+	struct start_args *args = p;
+	int (*start)(void*) = (int(*)(void*)) args->start_func;
+	__pthread_exit((void *)(uintptr_t)start(args->start_arg));
+	return 0;
+}
+#else
+__attribute__((export_name("wasi_thread_start")))
+_Noreturn void wasi_thread_start(int tid, void *p)
+{
+	struct start_args *args = p;
+  	__asm__(".globaltype __tls_base, i32\n"
+			"local.get %0\n"
+			"global.set __tls_base\n"
+			:: "r"(args->tls_base));
+	pthread_t self = __pthread_self();
+	// Set the thread ID (TID) on the pthread structure. The TID is stored
+	// atomically since it is also stored by the parent thread; this way,
+	// whichever thread (parent or child) reaches this point first can proceed
+	// without waiting.
+	atomic_store((atomic_int *) &(self->tid), tid);
+	// Set the stack pointer.
+  	__asm__(".globaltype __stack_pointer, i32\n"
+			"local.get %0\n"
+			"global.set __stack_pointer\n"
+			:: "r"(self->stack));
+	// Execute the user's start function.
+	int (*start)(void*) = (int(*)(void*)) args->start_func;
+	__pthread_exit((void *)(uintptr_t)start(args->start_arg));
+}
+#endif
+
+#define ROUND(x) (((x)+PAGE_SIZE-1)&-PAGE_SIZE)
+
+/* pthread_key_create.c overrides this */
+static volatile size_t dummy = 0;
+weak_alias(dummy, __pthread_tsd_size);
+static void *dummy_tsd[1] = { 0 };
+weak_alias(dummy_tsd, __pthread_tsd_main);
+
+static FILE *volatile dummy_file = 0;
+weak_alias(dummy_file, __stdin_used);
+weak_alias(dummy_file, __stdout_used);
+weak_alias(dummy_file, __stderr_used);
+
+static void init_file_lock(FILE *f)
+{
+	if (f && f->lock<0) f->lock = 0;
+}
+
+int __pthread_create(pthread_t *restrict res, const pthread_attr_t *restrict attrp, void *(*entry)(void *), void *restrict arg)
+{
+	int ret, c11 = (attrp == __ATTRP_C11_THREAD);
+	size_t size, guard;
+	struct pthread *self, *new;
+	unsigned char *map = 0, *stack = 0, *tsd = 0, *stack_limit;
+#ifdef __wasilibc_unmodified_upstream
+	unsigned flags = CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND
+		| CLONE_THREAD | CLONE_SYSVSEM | CLONE_SETTLS
+		| CLONE_PARENT_SETTID | CLONE_CHILD_CLEARTID | CLONE_DETACHED;
+#endif
+	pthread_attr_t attr = { 0 };
+	sigset_t set;
+#ifndef __wasilibc_unmodified_upstream
+	size_t tls_size = __builtin_wasm_tls_size();
+	size_t tls_align = __builtin_wasm_tls_align();
+	void* tls_base = __builtin_wasm_tls_base();
+	void* new_tls_base;
+	size_t tls_offset;
+	tls_size += tls_align;
+#endif
+
+#ifdef __wasilibc_unmodified_upstream
+	if (!libc.can_do_threads) return ENOSYS;
+#endif
+	self = __pthread_self();
+	if (!libc.threaded) {
+		for (FILE *f=*__ofl_lock(); f; f=f->next)
+			init_file_lock(f);
+		__ofl_unlock();
+		init_file_lock(__stdin_used);
+		init_file_lock(__stdout_used);
+		init_file_lock(__stderr_used);
+#ifdef __wasilibc_unmodified_upstream
+		__syscall(SYS_rt_sigprocmask, SIG_UNBLOCK, SIGPT_SET, 0, _NSIG/8);
+#endif
+		self->tsd = (void **)__pthread_tsd_main;
+#ifdef __wasilibc_unmodified_upstream
+		__membarrier_init();
+#endif
+		libc.threaded = 1;
+	}
+	if (attrp && !c11) attr = *attrp;
+
+	__acquire_ptc();
+	if (!attrp || c11) {
+		attr._a_stacksize = __default_stacksize;
+		attr._a_guardsize = __default_guardsize;
+	}
+
+	if (attr._a_stackaddr) {
+#ifdef __wasilibc_unmodified_upstream
+		size_t need = libc.tls_size + __pthread_tsd_size;
+#else
+		size_t need = tls_size + __pthread_tsd_size;
+#endif
+		size = attr._a_stacksize;
+		stack = (void *)(attr._a_stackaddr & -16);
+		stack_limit = (void *)(attr._a_stackaddr - size);
+		/* Use application-provided stack for TLS only when
+		 * it does not take more than ~12% or 2k of the
+		 * application's stack space. */
+		if (need < size/8 && need < 2048) {
+			tsd = stack - __pthread_tsd_size;
+#ifdef __wasilibc_unmodified_upstream
+			stack = tsd - libc.tls_size;
+#else
+			stack = tsd - tls_size;
+#endif
+			memset(stack, 0, need);
+		} else {
+			size = ROUND(need);
+		}
+		guard = 0;
+	} else {
+		guard = ROUND(attr._a_guardsize);
+		size = guard + ROUND(attr._a_stacksize
+#ifdef __wasilibc_unmodified_upstream
+			+ libc.tls_size +  __pthread_tsd_size);
+#else
+			+ tls_size +  __pthread_tsd_size);
+#endif
+	}
+
+	if (!tsd) {
+#ifdef __wasilibc_unmodified_upstream
+		if (guard) {
+			map = __mmap(0, size, PROT_NONE, MAP_PRIVATE|MAP_ANON, -1, 0);
+			if (map == MAP_FAILED) goto fail;
+			if (__mprotect(map+guard, size-guard, PROT_READ|PROT_WRITE)
+			    && errno != ENOSYS) {
+				__munmap(map, size);
+				goto fail;
+			}
+		} else {
+			map = __mmap(0, size, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANON, -1, 0);
+			if (map == MAP_FAILED) goto fail;
+		}
+#else
+		map = malloc(size);
+		if (!map) goto fail;
+#endif
+		tsd = map + size - __pthread_tsd_size;
+		if (!stack) {
+#ifdef __wasilibc_unmodified_upstream
+			stack = tsd - libc.tls_size;
+#else
+			stack = tsd - tls_size;
+#endif
+			stack_limit = map + guard;
+		}
+	}
+
+#ifdef __wasilibc_unmodified_upstream
+	new = __copy_tls(tsd - libc.tls_size);
+#else
+	new_tls_base = __copy_tls(tsd - tls_size);
+	tls_offset = new_tls_base - tls_base;
+	new = (void*)((uintptr_t)self + tls_offset);
+#endif
+	new->map_base = map;
+	new->map_size = size;
+	new->stack = stack;
+	new->stack_size = stack - stack_limit;
+	new->guard_size = guard;
+	new->self = new;
+	new->tsd = (void *)tsd;
+	new->locale = &libc.global_locale;
+	if (attr._a_detach) {
+		new->detach_state = DT_DETACHED;
+	} else {
+		new->detach_state = DT_JOINABLE;
+	}
+	new->robust_list.head = &new->robust_list.head;
+	new->canary = self->canary;
+	new->sysinfo = self->sysinfo;
+
+	/* Setup argument structure for the new thread on its stack.
+	 * It's safe to access from the caller only until the thread
+	 * list is unlocked. */
+#ifdef __wasilibc_unmodified_upstream
+	stack -= (uintptr_t)stack % sizeof(uintptr_t);
+	stack -= sizeof(struct start_args);
+	struct start_args *args = (void *)stack;
+	args->start_func = entry;
+	args->start_arg = arg;
+	args->control = attr._a_sched ? 1 : 0;
+
+	/* Application signals (but not the synccall signal) must be
+	 * blocked before the thread list lock can be taken, to ensure
+	 * that the lock is AS-safe. */
+	__block_app_sigs(&set);
+
+	/* Ensure SIGCANCEL is unblocked in new thread. This requires
+	 * working with a copy of the set so we can restore the
+	 * original mask in the calling thread. */
+	memcpy(&args->sig_mask, &set, sizeof args->sig_mask);
+	args->sig_mask[(SIGCANCEL-1)/8/sizeof(long)] &=
+		~(1UL<<((SIGCANCEL-1)%(8*sizeof(long))));
+#else
+	/* Align the stack to struct start_args */
+	stack -= sizeof(struct start_args);
+	stack -= (uintptr_t)stack % alignof(struct start_args);
+	struct start_args *args = (void *)stack;
+
+	/* Align the stack to 16 and store it */
+	new->stack = (void *)((uintptr_t) stack & -16);
+	/* Correct the stack size */
+	new->stack_size = stack - stack_limit;
+
+	args->start_func = entry;
+	args->start_arg = arg;
+	args->tls_base = (void*)new_tls_base;
+#endif
+
+	__tl_lock();
+	if (!libc.threads_minus_1++) libc.need_locks = 1;
+#ifdef __wasilibc_unmodified_upstream
+	ret = __clone((c11 ? start_c11 : start), stack, flags, args, &new->tid, TP_ADJ(new), &__thread_list_lock);
+#else
+	/* Instead of `__clone`, WASI uses a host API to instantiate a new version
+	 * of the current module and start executing the entry function. The
+	 * wasi-threads specification requires the module to export a
+	 * `wasi_thread_start` function, which is invoked with `args`. */
+	ret = __wasi_thread_spawn((void *) args);
+#endif
+
+#ifdef __wasilibc_unmodified_upstream
+	/* All clone failures translate to EAGAIN. If explicit scheduling
+	 * was requested, attempt it before unlocking the thread list so
+	 * that the failed thread is never exposed and so that we can
+	 * clean up all transient resource usage before returning. */
+	if (ret < 0) {
+		ret = -EAGAIN;
+	} else if (attr._a_sched) {
+		ret = __syscall(SYS_sched_setscheduler,
+			new->tid, attr._a_policy, &attr._a_prio);
+		if (a_swap(&args->control, ret ? 3 : 0)==2)
+			__wake(&args->control, 1, 1);
+		if (ret)
+			__wait(&args->control, 0, 3, 0);
+	}
+#else
+	/* `wasi_thread_spawn` will either return a host-provided thread ID (TID)
+	 * (`>= 0`) or an error code (`< 0`). As in the unmodified version, all
+	 * spawn failures translate to EAGAIN; unlike the modified version, there is
+	 * no need to "start up" the child thread--the host does this. If the spawn
+	 * did succeed, then we store the TID atomically, since this parent thread
+	 * is racing with the child thread to set this field; this way, whichever
+	 * thread reaches this point first can continue without waiting. */
+	if (ret < 0) {
+		ret = -EAGAIN;
+	} else {
+		atomic_store((atomic_int *) &(new->tid), ret);
+	}
+#endif
+
+	if (ret >= 0) {
+		new->next = self->next;
+		new->prev = self;
+		new->next->prev = new;
+		new->prev->next = new;
+	} else {
+		if (!--libc.threads_minus_1) libc.need_locks = 0;
+	}
+	__tl_unlock();
+#ifdef __wasilibc_unmodified_upstream
+	__restore_sigs(&set);
+#endif
+	__release_ptc();
+
+	if (ret < 0) {
+#ifdef __wasilibc_unmodified_upstream
+		if (map) __munmap(map, size);
+#else
+		free(map);
+#endif
+		return -ret;
+	}
+
+	*res = new;
+	return 0;
+fail:
+	__release_ptc();
+	return EAGAIN;
+}
+
+weak_alias(__pthread_exit, pthread_exit);
+weak_alias(__pthread_create, pthread_create);
diff --git a/libc-top-half/musl/src/thread/pthread_detach.c b/libc-top-half/musl/src/thread/pthread_detach.c
new file mode 100644
index 0000000..77772af
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_detach.c
@@ -0,0 +1,14 @@
+#include "pthread_impl.h"
+#include <threads.h>
+
+static int __pthread_detach(pthread_t t)
+{
+	/* If the cas fails, detach state is either already-detached
+	 * or exiting/exited, and pthread_join will trap or cleanup. */
+	if (a_cas(&t->detach_state, DT_JOINABLE, DT_DETACHED) != DT_JOINABLE)
+		return __pthread_join(t, 0);
+	return 0;
+}
+
+weak_alias(__pthread_detach, pthread_detach);
+weak_alias(__pthread_detach, thrd_detach);
diff --git a/libc-top-half/musl/src/thread/pthread_equal.c b/libc-top-half/musl/src/thread/pthread_equal.c
new file mode 100644
index 0000000..dbb7365
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_equal.c
@@ -0,0 +1,10 @@
+#include <pthread.h>
+#include <threads.h>
+
+static int __pthread_equal(pthread_t a, pthread_t b)
+{
+	return a==b;
+}
+
+weak_alias(__pthread_equal, pthread_equal);
+weak_alias(__pthread_equal, thrd_equal);
diff --git a/libc-top-half/musl/src/thread/pthread_getattr_np.c b/libc-top-half/musl/src/thread/pthread_getattr_np.c
new file mode 100644
index 0000000..2881831
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_getattr_np.c
@@ -0,0 +1,24 @@
+#define _GNU_SOURCE
+#include "pthread_impl.h"
+#include "libc.h"
+#include <sys/mman.h>
+
+int pthread_getattr_np(pthread_t t, pthread_attr_t *a)
+{
+	*a = (pthread_attr_t){0};
+	a->_a_detach = t->detach_state>=DT_DETACHED;
+	a->_a_guardsize = t->guard_size;
+	if (t->stack) {
+		a->_a_stackaddr = (uintptr_t)t->stack;
+		a->_a_stacksize = t->stack_size;
+	} else {
+		char *p = (void *)libc.auxv;
+		size_t l = PAGE_SIZE;
+		p += -(uintptr_t)p & PAGE_SIZE-1;
+		a->_a_stackaddr = (uintptr_t)p;
+		while (mremap(p-l-PAGE_SIZE, PAGE_SIZE, 2*PAGE_SIZE, 0)==MAP_FAILED && errno==ENOMEM)
+			l += PAGE_SIZE;
+		a->_a_stacksize = l;
+	}
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_getconcurrency.c b/libc-top-half/musl/src/thread/pthread_getconcurrency.c
new file mode 100644
index 0000000..269429a
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_getconcurrency.c
@@ -0,0 +1,6 @@
+#include <pthread.h>
+
+int pthread_getconcurrency()
+{
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_getcpuclockid.c b/libc-top-half/musl/src/thread/pthread_getcpuclockid.c
new file mode 100644
index 0000000..9df14fb
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_getcpuclockid.c
@@ -0,0 +1,7 @@
+#include "pthread_impl.h"
+
+int pthread_getcpuclockid(pthread_t t, clockid_t *clockid)
+{
+	*clockid = (-t->tid-1)*8U + 6;
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_getname_np.c b/libc-top-half/musl/src/thread/pthread_getname_np.c
new file mode 100644
index 0000000..85504e4
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_getname_np.c
@@ -0,0 +1,25 @@
+#define _GNU_SOURCE
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/prctl.h>
+
+#include "pthread_impl.h"
+
+int pthread_getname_np(pthread_t thread, char *name, size_t len)
+{
+	int fd, cs, status = 0;
+	char f[sizeof "/proc/self/task//comm" + 3*sizeof(int)];
+
+	if (len < 16) return ERANGE;
+
+	if (thread == pthread_self())
+		return prctl(PR_GET_NAME, (unsigned long)name, 0UL, 0UL, 0UL) ? errno : 0;
+
+	snprintf(f, sizeof f, "/proc/self/task/%d/comm", thread->tid);
+	pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cs);
+	if ((fd = open(f, O_RDONLY|O_CLOEXEC)) < 0 || (len = read(fd, name, len)) == -1) status = errno;
+	else name[len-1] = 0; /* remove trailing new line only if successful */
+	if (fd >= 0) close(fd);
+	pthread_setcancelstate(cs, 0);
+	return status;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_getschedparam.c b/libc-top-half/musl/src/thread/pthread_getschedparam.c
new file mode 100644
index 0000000..c098bef
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_getschedparam.c
@@ -0,0 +1,21 @@
+#include "pthread_impl.h"
+#include "lock.h"
+
+int pthread_getschedparam(pthread_t t, int *restrict policy, struct sched_param *restrict param)
+{
+	int r;
+	sigset_t set;
+	__block_app_sigs(&set);
+	LOCK(t->killlock);
+	if (!t->tid) {
+		r = ESRCH;
+	} else {
+		r = -__syscall(SYS_sched_getparam, t->tid, param);
+		if (!r) {
+			*policy = __syscall(SYS_sched_getscheduler, t->tid);
+		}
+	}
+	UNLOCK(t->killlock);
+	__restore_sigs(&set);
+	return r;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_getspecific.c b/libc-top-half/musl/src/thread/pthread_getspecific.c
new file mode 100644
index 0000000..d9342a5
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_getspecific.c
@@ -0,0 +1,11 @@
+#include "pthread_impl.h"
+#include <threads.h>
+
+static void *__pthread_getspecific(pthread_key_t k)
+{
+	struct pthread *self = __pthread_self();
+	return self->tsd[k];
+}
+
+weak_alias(__pthread_getspecific, pthread_getspecific);
+weak_alias(__pthread_getspecific, tss_get);
diff --git a/libc-top-half/musl/src/thread/pthread_join.c b/libc-top-half/musl/src/thread/pthread_join.c
new file mode 100644
index 0000000..b06e7e7
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_join.c
@@ -0,0 +1,46 @@
+#define _GNU_SOURCE
+#include "pthread_impl.h"
+#ifdef __wasilibc_unmodified_upstream
+#include <sys/mman.h>
+#endif
+
+static void dummy1(pthread_t t)
+{
+}
+weak_alias(dummy1, __tl_sync);
+
+static int __pthread_timedjoin_np(pthread_t t, void **res, const struct timespec *at)
+{
+	int state, cs, r = 0;
+	__pthread_testcancel();
+	__pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cs);
+	if (cs == PTHREAD_CANCEL_ENABLE) __pthread_setcancelstate(cs, 0);
+	while ((state = t->detach_state) && r != ETIMEDOUT && r != EINVAL) {
+		if (state >= DT_DETACHED) a_crash();
+		r = __timedwait_cp(&t->detach_state, state, CLOCK_REALTIME, at, 1);
+	}
+	__pthread_setcancelstate(cs, 0);
+	if (r == ETIMEDOUT || r == EINVAL) return r;
+	__tl_sync(t);
+	if (res) *res = t->result;
+#ifdef __wasilibc_unmodified_upstream
+	if (t->map_base) __munmap(t->map_base, t->map_size);
+#else
+	if (t->map_base) free(t->map_base);
+#endif
+	return 0;
+}
+
+int __pthread_join(pthread_t t, void **res)
+{
+	return __pthread_timedjoin_np(t, res, 0);
+}
+
+static int __pthread_tryjoin_np(pthread_t t, void **res)
+{
+	return t->detach_state==DT_JOINABLE ? EBUSY : __pthread_join(t, res);
+}
+
+weak_alias(__pthread_tryjoin_np, pthread_tryjoin_np);
+weak_alias(__pthread_timedjoin_np, pthread_timedjoin_np);
+weak_alias(__pthread_join, pthread_join);
diff --git a/libc-top-half/musl/src/thread/pthread_key_create.c b/libc-top-half/musl/src/thread/pthread_key_create.c
new file mode 100644
index 0000000..dd47caa
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_key_create.c
@@ -0,0 +1,95 @@
+#include "pthread_impl.h"
+
+volatile size_t __pthread_tsd_size = sizeof(void *) * PTHREAD_KEYS_MAX;
+void *__pthread_tsd_main[PTHREAD_KEYS_MAX] = { 0 };
+
+static void (*keys[PTHREAD_KEYS_MAX])(void *);
+
+static pthread_rwlock_t key_lock = PTHREAD_RWLOCK_INITIALIZER;
+
+static pthread_key_t next_key;
+
+static void nodtor(void *dummy)
+{
+}
+
+static void dummy_0(void)
+{
+}
+
+weak_alias(dummy_0, __tl_lock);
+weak_alias(dummy_0, __tl_unlock);
+
+int __pthread_key_create(pthread_key_t *k, void (*dtor)(void *))
+{
+	pthread_t self = __pthread_self();
+
+	/* This can only happen in the main thread before
+	 * pthread_create has been called. */
+	if (!self->tsd) self->tsd = __pthread_tsd_main;
+
+	/* Purely a sentinel value since null means slot is free. */
+	if (!dtor) dtor = nodtor;
+
+	__pthread_rwlock_wrlock(&key_lock);
+	pthread_key_t j = next_key;
+	do {
+		if (!keys[j]) {
+			keys[next_key = *k = j] = dtor;
+			__pthread_rwlock_unlock(&key_lock);
+			return 0;
+		}
+	} while ((j=(j+1)%PTHREAD_KEYS_MAX) != next_key);
+
+	__pthread_rwlock_unlock(&key_lock);
+	return EAGAIN;
+}
+
+int __pthread_key_delete(pthread_key_t k)
+{
+	sigset_t set;
+	pthread_t self = __pthread_self(), td=self;
+
+#ifdef __wasilibc_unmodified_upstream
+	__block_app_sigs(&set);
+#endif
+	__pthread_rwlock_wrlock(&key_lock);
+
+	__tl_lock();
+	do td->tsd[k] = 0;
+	while ((td=td->next)!=self);
+	__tl_unlock();
+
+	keys[k] = 0;
+
+	__pthread_rwlock_unlock(&key_lock);
+#ifdef __wasilibc_unmodified_upstream
+	__restore_sigs(&set);
+#endif
+
+	return 0;
+}
+
+void __pthread_tsd_run_dtors()
+{
+	pthread_t self = __pthread_self();
+	int i, j;
+	for (j=0; self->tsd_used && j<PTHREAD_DESTRUCTOR_ITERATIONS; j++) {
+		__pthread_rwlock_rdlock(&key_lock);
+		self->tsd_used = 0;
+		for (i=0; i<PTHREAD_KEYS_MAX; i++) {
+			void *val = self->tsd[i];
+			void (*dtor)(void *) = keys[i];
+			self->tsd[i] = 0;
+			if (val && dtor && dtor != nodtor) {
+				__pthread_rwlock_unlock(&key_lock);
+				dtor(val);
+				__pthread_rwlock_rdlock(&key_lock);
+			}
+		}
+		__pthread_rwlock_unlock(&key_lock);
+	}
+}
+
+weak_alias(__pthread_key_create, pthread_key_create);
+weak_alias(__pthread_key_delete, pthread_key_delete);
diff --git a/libc-top-half/musl/src/thread/pthread_kill.c b/libc-top-half/musl/src/thread/pthread_kill.c
new file mode 100644
index 0000000..79ddb20
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_kill.c
@@ -0,0 +1,18 @@
+#include "pthread_impl.h"
+#include "lock.h"
+
+int pthread_kill(pthread_t t, int sig)
+{
+	int r;
+	sigset_t set;
+	/* Block not just app signals, but internal ones too, since
+	 * pthread_kill is used to implement pthread_cancel, which
+	 * must be async-cancel-safe. */
+	__block_all_sigs(&set);
+	LOCK(t->killlock);
+	r = t->tid ? -__syscall(SYS_tkill, t->tid, sig)
+		: (sig+0U >= _NSIG ? EINVAL : 0);
+	UNLOCK(t->killlock);
+	__restore_sigs(&set);
+	return r;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_mutex_consistent.c b/libc-top-half/musl/src/thread/pthread_mutex_consistent.c
new file mode 100644
index 0000000..27c74e5
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_mutex_consistent.c
@@ -0,0 +1,14 @@
+#include "pthread_impl.h"
+#include "atomic.h"
+
+int pthread_mutex_consistent(pthread_mutex_t *m)
+{
+	int old = m->_m_lock;
+	int own = old & 0x3fffffff;
+	if (!(m->_m_type & 4) || !own || !(old & 0x40000000))
+		return EINVAL;
+	if (own != __pthread_self()->tid)
+		return EPERM;
+	a_and(&m->_m_lock, ~0x40000000);
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_mutex_destroy.c b/libc-top-half/musl/src/thread/pthread_mutex_destroy.c
new file mode 100644
index 0000000..e53c39c
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_mutex_destroy.c
@@ -0,0 +1,18 @@
+#include "pthread_impl.h"
+
+int pthread_mutex_destroy(pthread_mutex_t *mutex)
+{
+#ifdef __wasilibc_unmodified_upstream
+	/* If the mutex being destroyed is process-shared and has nontrivial
+	 * type (tracking ownership), it might be in the pending slot of a
+	 * robust_list; wait for quiescence. */
+	if (mutex->_m_type > 128) __vm_wait();
+#else
+	/* For now, wasi-libc chooses to avoid implementing robust mutex support
+	 * though this could be added later. The error code indicates that the
+	 * mutex was an invalid type, but it would be more accurate as 
+	 * "unimplemented". */
+	if (mutex->_m_type > 128) return EINVAL;
+#endif
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_mutex_getprioceiling.c b/libc-top-half/musl/src/thread/pthread_mutex_getprioceiling.c
new file mode 100644
index 0000000..8c75a66
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_mutex_getprioceiling.c
@@ -0,0 +1,6 @@
+#include "pthread_impl.h"
+
+int pthread_mutex_getprioceiling(const pthread_mutex_t *restrict m, int *restrict ceiling)
+{
+	return EINVAL;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_mutex_init.c b/libc-top-half/musl/src/thread/pthread_mutex_init.c
new file mode 100644
index 0000000..acf45a7
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_mutex_init.c
@@ -0,0 +1,8 @@
+#include "pthread_impl.h"
+
+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;
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_mutex_lock.c b/libc-top-half/musl/src/thread/pthread_mutex_lock.c
new file mode 100644
index 0000000..638d4b8
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_mutex_lock.c
@@ -0,0 +1,12 @@
+#include "pthread_impl.h"
+
+int __pthread_mutex_lock(pthread_mutex_t *m)
+{
+	if ((m->_m_type&15) == PTHREAD_MUTEX_NORMAL
+	    && !a_cas(&m->_m_lock, 0, EBUSY))
+		return 0;
+
+	return __pthread_mutex_timedlock(m, 0);
+}
+
+weak_alias(__pthread_mutex_lock, pthread_mutex_lock);
diff --git a/libc-top-half/musl/src/thread/pthread_mutex_setprioceiling.c b/libc-top-half/musl/src/thread/pthread_mutex_setprioceiling.c
new file mode 100644
index 0000000..681f07c
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_mutex_setprioceiling.c
@@ -0,0 +1,6 @@
+#include "pthread_impl.h"
+
+int pthread_mutex_setprioceiling(pthread_mutex_t *restrict m, int ceiling, int *restrict old)
+{
+	return EINVAL;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_mutex_timedlock.c b/libc-top-half/musl/src/thread/pthread_mutex_timedlock.c
new file mode 100644
index 0000000..d22196a
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_mutex_timedlock.c
@@ -0,0 +1,96 @@
+#include "pthread_impl.h"
+
+#ifdef __wasilibc_unmodified_upstream
+#define IS32BIT(x) !((x)+0x80000000ULL>>32)
+#define CLAMP(x) (int)(IS32BIT(x) ? (x) : 0x7fffffffU+((0ULL+(x))>>63))
+
+static int __futex4(volatile void *addr, int op, int val, const struct timespec *to)
+{
+#ifdef SYS_futex_time64
+	time_t s = to ? to->tv_sec : 0;
+	long ns = to ? to->tv_nsec : 0;
+	int r = -ENOSYS;
+	if (SYS_futex == SYS_futex_time64 || !IS32BIT(s))
+		r = __syscall(SYS_futex_time64, addr, op, val,
+			to ? ((long long[]){s, ns}) : 0);
+	if (SYS_futex == SYS_futex_time64 || r!=-ENOSYS) return r;
+	to = to ? (void *)(long[]){CLAMP(s), ns} : 0;
+#endif
+	return __syscall(SYS_futex, addr, op, val, to);
+}
+
+static int pthread_mutex_timedlock_pi(pthread_mutex_t *restrict m, const struct timespec *restrict at)
+{
+	int type = m->_m_type;
+	int priv = (type & 128) ^ 128;
+	pthread_t self = __pthread_self();
+	int e;
+
+	if (!priv) self->robust_list.pending = &m->_m_next;
+
+	do e = -__futex4(&m->_m_lock, FUTEX_LOCK_PI|priv, 0, at);
+	while (e==EINTR);
+	if (e) self->robust_list.pending = 0;
+
+	switch (e) {
+	case 0:
+		/* Catch spurious success for non-robust mutexes. */
+		if (!(type&4) && ((m->_m_lock & 0x40000000) || m->_m_waiters)) {
+			a_store(&m->_m_waiters, -1);
+			__syscall(SYS_futex, &m->_m_lock, FUTEX_UNLOCK_PI|priv);
+			self->robust_list.pending = 0;
+			break;
+		}
+		/* Signal to trylock that we already have the lock. */
+		m->_m_count = -1;
+		return __pthread_mutex_trylock(m);
+	case ETIMEDOUT:
+		return e;
+	case EDEADLK:
+		if ((type&3) == PTHREAD_MUTEX_ERRORCHECK) return e;
+	}
+	do e = __timedwait(&(int){0}, 0, CLOCK_REALTIME, at, 1);
+	while (e != ETIMEDOUT);
+	return e;
+}
+#endif
+
+int __pthread_mutex_timedlock(pthread_mutex_t *restrict m, const struct timespec *restrict at)
+{
+	if ((m->_m_type&15) == PTHREAD_MUTEX_NORMAL
+	    && !a_cas(&m->_m_lock, 0, EBUSY))
+		return 0;
+
+	int type = m->_m_type;
+	int r, t, priv = (type & 128) ^ 128;
+
+	r = __pthread_mutex_trylock(m);
+	if (r != EBUSY) return r;
+
+#ifdef __wasilibc_unmodified_upstream
+	if (type&8) return pthread_mutex_timedlock_pi(m, at);
+#endif
+
+	int spins = 100;
+	while (spins-- && m->_m_lock && !m->_m_waiters) a_spin();
+
+	while ((r=__pthread_mutex_trylock(m)) == EBUSY) {
+		r = m->_m_lock;
+		int own = r & 0x3fffffff;
+		if (!own && (!r || (type&4)))
+			continue;
+		if ((type&3) == PTHREAD_MUTEX_ERRORCHECK
+		    && own == __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, priv);
+		a_dec(&m->_m_waiters);
+		if (r && r != EINTR) break;
+	}
+	return r;
+}
+
+weak_alias(__pthread_mutex_timedlock, pthread_mutex_timedlock);
diff --git a/libc-top-half/musl/src/thread/pthread_mutex_trylock.c b/libc-top-half/musl/src/thread/pthread_mutex_trylock.c
new file mode 100644
index 0000000..c60b45f
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_mutex_trylock.c
@@ -0,0 +1,78 @@
+#include "pthread_impl.h"
+
+int __pthread_mutex_trylock_owner(pthread_mutex_t *m)
+{
+	int old, own;
+	int type = m->_m_type;
+	pthread_t self = __pthread_self();
+	int tid = self->tid;
+
+	old = m->_m_lock;
+	own = old & 0x3fffffff;
+	if (own == tid) {
+		if ((type&8) && m->_m_count<0) {
+			old &= 0x40000000;
+			m->_m_count = 0;
+			goto success;
+		}
+		if ((type&3) == PTHREAD_MUTEX_RECURSIVE) {
+			if ((unsigned)m->_m_count >= INT_MAX) return EAGAIN;
+			m->_m_count++;
+			return 0;
+		}
+	}
+	if (own == 0x3fffffff) return ENOTRECOVERABLE;
+	if (own || (old && !(type & 4))) return EBUSY;
+
+	if (type & 128) {
+		if (!self->robust_list.off) {
+			self->robust_list.off = (char*)&m->_m_lock-(char *)&m->_m_next;
+#ifdef __wasilibc_unmodified_upstream
+			__syscall(SYS_set_robust_list, &self->robust_list, 3*sizeof(long));
+#endif
+		}
+		if (m->_m_waiters) tid |= 0x80000000;
+		self->robust_list.pending = &m->_m_next;
+	}
+	tid |= old & 0x40000000;
+
+	if (a_cas(&m->_m_lock, old, tid) != old) {
+		self->robust_list.pending = 0;
+		if ((type&12)==12 && m->_m_waiters) return ENOTRECOVERABLE;
+		return EBUSY;
+	}
+
+success:
+	if ((type&8) && m->_m_waiters) {
+		int priv = (type & 128) ^ 128;
+#ifdef __wasilibc_unmodified_upstream
+		__syscall(SYS_futex, &m->_m_lock, FUTEX_UNLOCK_PI|priv);
+#endif
+		self->robust_list.pending = 0;
+		return (type&4) ? ENOTRECOVERABLE : EBUSY;
+	}
+
+	volatile void *next = self->robust_list.head;
+	m->_m_next = next;
+	m->_m_prev = &self->robust_list.head;
+	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 (old) {
+		m->_m_count = 0;
+		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);
+}
+
+weak_alias(__pthread_mutex_trylock, pthread_mutex_trylock);
diff --git a/libc-top-half/musl/src/thread/pthread_mutex_unlock.c b/libc-top-half/musl/src/thread/pthread_mutex_unlock.c
new file mode 100644
index 0000000..6beaacb
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_mutex_unlock.c
@@ -0,0 +1,60 @@
+#include "pthread_impl.h"
+
+int __pthread_mutex_unlock(pthread_mutex_t *m)
+{
+	pthread_t self;
+	int waiters = m->_m_waiters;
+	int cont;
+	int type = m->_m_type & 15;
+	int priv = (m->_m_type & 128) ^ 128;
+	int new = 0;
+	int old;
+
+	if (type != PTHREAD_MUTEX_NORMAL) {
+		self = __pthread_self();
+		old = m->_m_lock;
+		int own = old & 0x3fffffff;
+		if (own != self->tid)
+			return EPERM;
+		if ((type&3) == PTHREAD_MUTEX_RECURSIVE && m->_m_count)
+			return m->_m_count--, 0;
+		if ((type&4) && (old&0x40000000))
+			new = 0x7fffffff;
+		if (!priv) {
+			self->robust_list.pending = &m->_m_next;
+#ifdef __wasilibc_unmodified_upstream
+			__vm_lock();
+#endif
+		}
+		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;
+	}
+#ifdef __wasilibc_unmodified_upstream
+	if (type&8) {
+		if (old<0 || a_cas(&m->_m_lock, old, new)!=old) {
+			if (new) a_store(&m->_m_waiters, -1);
+			__syscall(SYS_futex, &m->_m_lock, FUTEX_UNLOCK_PI|priv);
+		}
+		cont = 0;
+		waiters = 0;
+	} else {
+		cont = a_swap(&m->_m_lock, new);
+	}
+#else
+		cont = a_swap(&m->_m_lock, new);
+#endif
+	if (type != PTHREAD_MUTEX_NORMAL && !priv) {
+		self->robust_list.pending = 0;
+#ifdef __wasilibc_unmodified_upstream
+		__vm_unlock();
+#endif
+	}
+	if (waiters || cont<0)
+		__wake(&m->_m_lock, 1, priv);
+	return 0;
+}
+
+weak_alias(__pthread_mutex_unlock, pthread_mutex_unlock);
diff --git a/libc-top-half/musl/src/thread/pthread_mutexattr_destroy.c b/libc-top-half/musl/src/thread/pthread_mutexattr_destroy.c
new file mode 100644
index 0000000..9fd6974
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_mutexattr_destroy.c
@@ -0,0 +1,6 @@
+#include "pthread_impl.h"
+
+int pthread_mutexattr_destroy(pthread_mutexattr_t *a)
+{
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_mutexattr_init.c b/libc-top-half/musl/src/thread/pthread_mutexattr_init.c
new file mode 100644
index 0000000..0b72c1b
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_mutexattr_init.c
@@ -0,0 +1,7 @@
+#include "pthread_impl.h"
+
+int pthread_mutexattr_init(pthread_mutexattr_t *a)
+{
+	*a = (pthread_mutexattr_t){0};
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_mutexattr_setprotocol.c b/libc-top-half/musl/src/thread/pthread_mutexattr_setprotocol.c
new file mode 100644
index 0000000..84b02ba
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_mutexattr_setprotocol.c
@@ -0,0 +1,32 @@
+#include "pthread_impl.h"
+#include "syscall.h"
+
+static volatile int check_pi_result = -1;
+
+int pthread_mutexattr_setprotocol(pthread_mutexattr_t *a, int protocol)
+{
+	int r;
+	switch (protocol) {
+	case PTHREAD_PRIO_NONE:
+		a->__attr &= ~8;
+		return 0;
+	case PTHREAD_PRIO_INHERIT:
+#ifdef __wasilibc_unmodified_upstream
+		r = check_pi_result;
+		if (r < 0) {
+			volatile int lk = 0;
+			r = -__syscall(SYS_futex, &lk, FUTEX_LOCK_PI, 0, 0);
+			a_store(&check_pi_result, r);
+		}
+		if (r) return r;
+		a->__attr |= 8;
+		return 0;
+#else
+		return ENOTSUP;
+#endif
+	case PTHREAD_PRIO_PROTECT:
+		return ENOTSUP;
+	default:
+		return EINVAL;
+	}
+}
diff --git a/libc-top-half/musl/src/thread/pthread_mutexattr_setpshared.c b/libc-top-half/musl/src/thread/pthread_mutexattr_setpshared.c
new file mode 100644
index 0000000..100f6ff
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_mutexattr_setpshared.c
@@ -0,0 +1,9 @@
+#include "pthread_impl.h"
+
+int pthread_mutexattr_setpshared(pthread_mutexattr_t *a, int pshared)
+{
+	if (pshared > 1U) return EINVAL;
+	a->__attr &= ~128U;
+	a->__attr |= pshared<<7;
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_mutexattr_setrobust.c b/libc-top-half/musl/src/thread/pthread_mutexattr_setrobust.c
new file mode 100644
index 0000000..649a891
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_mutexattr_setrobust.c
@@ -0,0 +1,27 @@
+#include "pthread_impl.h"
+#include "syscall.h"
+
+static volatile int check_robust_result = -1;
+
+int pthread_mutexattr_setrobust(pthread_mutexattr_t *a, int robust)
+{
+#ifdef __wasilibc_unmodified_upstream
+	if (robust > 1U) return EINVAL;
+	if (robust) {
+		int r = check_robust_result;
+		if (r < 0) {
+			void *p;
+			size_t l;
+			r = -__syscall(SYS_get_robust_list, 0, &p, &l);
+			a_store(&check_robust_result, r);
+		}
+		if (r) return r;
+		a->__attr |= 4;
+		return 0;
+	}
+	a->__attr &= ~4;
+	return 0;
+#else
+	return EINVAL;
+#endif
+}
diff --git a/libc-top-half/musl/src/thread/pthread_mutexattr_settype.c b/libc-top-half/musl/src/thread/pthread_mutexattr_settype.c
new file mode 100644
index 0000000..cd7a80e
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_mutexattr_settype.c
@@ -0,0 +1,8 @@
+#include "pthread_impl.h"
+
+int pthread_mutexattr_settype(pthread_mutexattr_t *a, int type)
+{
+	if ((unsigned)type > 2) return EINVAL;
+	a->__attr = (a->__attr & ~3) | type;
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_once.c b/libc-top-half/musl/src/thread/pthread_once.c
new file mode 100644
index 0000000..8e8d40a
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_once.c
@@ -0,0 +1,50 @@
+#include "pthread_impl.h"
+
+static void undo(void *control)
+{
+	/* Wake all waiters, since the waiter status is lost when
+	 * resetting control to the initial state. */
+	if (a_swap(control, 0) == 3)
+		__wake(control, -1, 1);
+}
+
+hidden int __pthread_once_full(pthread_once_t *control, void (*init)(void))
+{
+	/* Try to enter initializing state. Four possibilities:
+	 *  0 - we're the first or the other cancelled; run init
+	 *  1 - another thread is running init; wait
+	 *  2 - another thread finished running init; just return
+	 *  3 - another thread is running init, waiters present; wait */
+
+	for (;;) switch (a_cas(control, 0, 1)) {
+	case 0:
+		pthread_cleanup_push(undo, control);
+		init();
+		pthread_cleanup_pop(0);
+
+		if (a_swap(control, 2) == 3)
+			__wake(control, -1, 1);
+		return 0;
+	case 1:
+		/* If this fails, so will __wait. */
+		a_cas(control, 1, 3);
+	case 3:
+		__wait(control, 0, 3, 1);
+		continue;
+	case 2:
+		return 0;
+	}
+}
+
+int __pthread_once(pthread_once_t *control, void (*init)(void))
+{
+	/* Return immediately if init finished before, but ensure that
+	 * effects of the init routine are visible to the caller. */
+	if (*(volatile int *)control == 2) {
+		a_barrier();
+		return 0;
+	}
+	return __pthread_once_full(control, init);
+}
+
+weak_alias(__pthread_once, pthread_once);
diff --git a/libc-top-half/musl/src/thread/pthread_rwlock_destroy.c b/libc-top-half/musl/src/thread/pthread_rwlock_destroy.c
new file mode 100644
index 0000000..49ecfbd
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_rwlock_destroy.c
@@ -0,0 +1,6 @@
+#include "pthread_impl.h"
+
+int pthread_rwlock_destroy(pthread_rwlock_t *rw)
+{
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_rwlock_init.c b/libc-top-half/musl/src/thread/pthread_rwlock_init.c
new file mode 100644
index 0000000..a2c0b47
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_rwlock_init.c
@@ -0,0 +1,8 @@
+#include "pthread_impl.h"
+
+int pthread_rwlock_init(pthread_rwlock_t *restrict rw, const pthread_rwlockattr_t *restrict a)
+{
+	*rw = (pthread_rwlock_t){0};
+	if (a) rw->_rw_shared = a->__attr[0]*128;
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_rwlock_rdlock.c b/libc-top-half/musl/src/thread/pthread_rwlock_rdlock.c
new file mode 100644
index 0000000..8546c07
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_rwlock_rdlock.c
@@ -0,0 +1,8 @@
+#include "pthread_impl.h"
+
+int __pthread_rwlock_rdlock(pthread_rwlock_t *rw)
+{
+	return __pthread_rwlock_timedrdlock(rw, 0);
+}
+
+weak_alias(__pthread_rwlock_rdlock, pthread_rwlock_rdlock);
diff --git a/libc-top-half/musl/src/thread/pthread_rwlock_timedrdlock.c b/libc-top-half/musl/src/thread/pthread_rwlock_timedrdlock.c
new file mode 100644
index 0000000..8cdd8ec
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_rwlock_timedrdlock.c
@@ -0,0 +1,25 @@
+#include "pthread_impl.h"
+
+int __pthread_rwlock_timedrdlock(pthread_rwlock_t *restrict rw, const struct timespec *restrict at)
+{
+	int r, t;
+
+	r = pthread_rwlock_tryrdlock(rw);
+	if (r != EBUSY) return r;
+	
+	int spins = 100;
+	while (spins-- && rw->_rw_lock && !rw->_rw_waiters) a_spin();
+
+	while ((r=__pthread_rwlock_tryrdlock(rw))==EBUSY) {
+		if (!(r=rw->_rw_lock) || (r&0x7fffffff)!=0x7fffffff) continue;
+		t = r | 0x80000000;
+		a_inc(&rw->_rw_waiters);
+		a_cas(&rw->_rw_lock, r, t);
+		r = __timedwait(&rw->_rw_lock, t, CLOCK_REALTIME, at, rw->_rw_shared^128);
+		a_dec(&rw->_rw_waiters);
+		if (r && r != EINTR) return r;
+	}
+	return r;
+}
+
+weak_alias(__pthread_rwlock_timedrdlock, pthread_rwlock_timedrdlock);
diff --git a/libc-top-half/musl/src/thread/pthread_rwlock_timedwrlock.c b/libc-top-half/musl/src/thread/pthread_rwlock_timedwrlock.c
new file mode 100644
index 0000000..d77706e
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_rwlock_timedwrlock.c
@@ -0,0 +1,25 @@
+#include "pthread_impl.h"
+
+int __pthread_rwlock_timedwrlock(pthread_rwlock_t *restrict rw, const struct timespec *restrict at)
+{
+	int r, t;
+	
+	r = pthread_rwlock_trywrlock(rw);
+	if (r != EBUSY) return r;
+	
+	int spins = 100;
+	while (spins-- && rw->_rw_lock && !rw->_rw_waiters) a_spin();
+
+	while ((r=__pthread_rwlock_trywrlock(rw))==EBUSY) {
+		if (!(r=rw->_rw_lock)) continue;
+		t = r | 0x80000000;
+		a_inc(&rw->_rw_waiters);
+		a_cas(&rw->_rw_lock, r, t);
+		r = __timedwait(&rw->_rw_lock, t, CLOCK_REALTIME, at, rw->_rw_shared^128);
+		a_dec(&rw->_rw_waiters);
+		if (r && r != EINTR) return r;
+	}
+	return r;
+}
+
+weak_alias(__pthread_rwlock_timedwrlock, pthread_rwlock_timedwrlock);
diff --git a/libc-top-half/musl/src/thread/pthread_rwlock_tryrdlock.c b/libc-top-half/musl/src/thread/pthread_rwlock_tryrdlock.c
new file mode 100644
index 0000000..c13bc9c
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_rwlock_tryrdlock.c
@@ -0,0 +1,15 @@
+#include "pthread_impl.h"
+
+int __pthread_rwlock_tryrdlock(pthread_rwlock_t *rw)
+{
+	int val, cnt;
+	do {
+		val = rw->_rw_lock;
+		cnt = val & 0x7fffffff;
+		if (cnt == 0x7fffffff) return EBUSY;
+		if (cnt == 0x7ffffffe) return EAGAIN;
+	} while (a_cas(&rw->_rw_lock, val, val+1) != val);
+	return 0;
+}
+
+weak_alias(__pthread_rwlock_tryrdlock, pthread_rwlock_tryrdlock);
diff --git a/libc-top-half/musl/src/thread/pthread_rwlock_trywrlock.c b/libc-top-half/musl/src/thread/pthread_rwlock_trywrlock.c
new file mode 100644
index 0000000..64d9d31
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_rwlock_trywrlock.c
@@ -0,0 +1,9 @@
+#include "pthread_impl.h"
+
+int __pthread_rwlock_trywrlock(pthread_rwlock_t *rw)
+{
+	if (a_cas(&rw->_rw_lock, 0, 0x7fffffff)) return EBUSY;
+	return 0;
+}
+
+weak_alias(__pthread_rwlock_trywrlock, pthread_rwlock_trywrlock);
diff --git a/libc-top-half/musl/src/thread/pthread_rwlock_unlock.c b/libc-top-half/musl/src/thread/pthread_rwlock_unlock.c
new file mode 100644
index 0000000..9ae27ad
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_rwlock_unlock.c
@@ -0,0 +1,20 @@
+#include "pthread_impl.h"
+
+int __pthread_rwlock_unlock(pthread_rwlock_t *rw)
+{
+	int val, cnt, waiters, new, priv = rw->_rw_shared^128;
+
+	do {
+		val = rw->_rw_lock;
+		cnt = val & 0x7fffffff;
+		waiters = rw->_rw_waiters;
+		new = (cnt == 0x7fffffff || cnt == 1) ? 0 : val-1;
+	} while (a_cas(&rw->_rw_lock, val, new) != val);
+
+	if (!new && (waiters || val<0))
+		__wake(&rw->_rw_lock, cnt, priv);
+
+	return 0;
+}
+
+weak_alias(__pthread_rwlock_unlock, pthread_rwlock_unlock);
diff --git a/libc-top-half/musl/src/thread/pthread_rwlock_wrlock.c b/libc-top-half/musl/src/thread/pthread_rwlock_wrlock.c
new file mode 100644
index 0000000..46a3b3a
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_rwlock_wrlock.c
@@ -0,0 +1,8 @@
+#include "pthread_impl.h"
+
+int __pthread_rwlock_wrlock(pthread_rwlock_t *rw)
+{
+	return __pthread_rwlock_timedwrlock(rw, 0);
+}
+
+weak_alias(__pthread_rwlock_wrlock, pthread_rwlock_wrlock);
diff --git a/libc-top-half/musl/src/thread/pthread_rwlockattr_destroy.c b/libc-top-half/musl/src/thread/pthread_rwlockattr_destroy.c
new file mode 100644
index 0000000..fc8d611
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_rwlockattr_destroy.c
@@ -0,0 +1,6 @@
+#include "pthread_impl.h"
+
+int pthread_rwlockattr_destroy(pthread_rwlockattr_t *a)
+{
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_rwlockattr_init.c b/libc-top-half/musl/src/thread/pthread_rwlockattr_init.c
new file mode 100644
index 0000000..e742069
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_rwlockattr_init.c
@@ -0,0 +1,7 @@
+#include "pthread_impl.h"
+
+int pthread_rwlockattr_init(pthread_rwlockattr_t *a)
+{
+	*a = (pthread_rwlockattr_t){0};
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_rwlockattr_setpshared.c b/libc-top-half/musl/src/thread/pthread_rwlockattr_setpshared.c
new file mode 100644
index 0000000..e706197
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_rwlockattr_setpshared.c
@@ -0,0 +1,8 @@
+#include "pthread_impl.h"
+
+int pthread_rwlockattr_setpshared(pthread_rwlockattr_t *a, int pshared)
+{
+	if (pshared > 1U) return EINVAL;
+	a->__attr[0] = pshared;
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_self.c b/libc-top-half/musl/src/thread/pthread_self.c
new file mode 100644
index 0000000..1f3eee1
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_self.c
@@ -0,0 +1,15 @@
+#include "pthread_impl.h"
+#include <threads.h>
+
+#if !defined(__wasilibc_unmodified_upstream) && defined(__wasm__) &&           \
+    defined(_REENTRANT)
+_Thread_local struct pthread __wasilibc_pthread_self;
+#endif
+
+static pthread_t __pthread_self_internal()
+{
+	return __pthread_self();
+}
+
+weak_alias(__pthread_self_internal, pthread_self);
+weak_alias(__pthread_self_internal, thrd_current);
diff --git a/libc-top-half/musl/src/thread/pthread_setattr_default_np.c b/libc-top-half/musl/src/thread/pthread_setattr_default_np.c
new file mode 100644
index 0000000..5848622
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_setattr_default_np.c
@@ -0,0 +1,37 @@
+#define _GNU_SOURCE
+#include "pthread_impl.h"
+#include <string.h>
+
+#define MIN(a,b) ((a)<(b) ? (a) : (b))
+#define MAX(a,b) ((a)>(b) ? (a) : (b))
+
+int pthread_setattr_default_np(const pthread_attr_t *attrp)
+{
+	/* Reject anything in the attr object other than stack/guard size. */
+	pthread_attr_t tmp = *attrp, zero = { 0 };
+	tmp._a_stacksize = 0;
+	tmp._a_guardsize = 0;
+	if (memcmp(&tmp, &zero, sizeof tmp))
+		return EINVAL;
+
+	unsigned stack = MIN(attrp->_a_stacksize, DEFAULT_STACK_MAX);
+	unsigned guard = MIN(attrp->_a_guardsize, DEFAULT_GUARD_MAX);
+
+	__inhibit_ptc();
+	__default_stacksize = MAX(__default_stacksize, stack);
+	__default_guardsize = MAX(__default_guardsize, guard);
+	__release_ptc();
+
+	return 0;
+}
+
+int pthread_getattr_default_np(pthread_attr_t *attrp)
+{
+	__acquire_ptc();
+	*attrp = (pthread_attr_t) {
+		._a_stacksize = __default_stacksize,
+		._a_guardsize = __default_guardsize,
+	};
+	__release_ptc();
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_setcancelstate.c b/libc-top-half/musl/src/thread/pthread_setcancelstate.c
new file mode 100644
index 0000000..4f7a00e
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_setcancelstate.c
@@ -0,0 +1,14 @@
+#include "pthread_impl.h"
+
+int __pthread_setcancelstate(int new, int *old)
+{
+#if defined(__wasilibc_unmodified_upstream) || defined(_REENTRANT)
+	if (new > 2U) return EINVAL;
+	struct pthread *self = __pthread_self();
+	if (old) *old = self->canceldisable;
+	self->canceldisable = new;
+#endif
+	return 0;
+}
+
+weak_alias(__pthread_setcancelstate, pthread_setcancelstate);
diff --git a/libc-top-half/musl/src/thread/pthread_setcanceltype.c b/libc-top-half/musl/src/thread/pthread_setcanceltype.c
new file mode 100644
index 0000000..bf0a3f3
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_setcanceltype.c
@@ -0,0 +1,11 @@
+#include "pthread_impl.h"
+
+int pthread_setcanceltype(int new, int *old)
+{
+	struct pthread *self = __pthread_self();
+	if (new > 1U) return EINVAL;
+	if (old) *old = self->cancelasync;
+	self->cancelasync = new;
+	if (new) pthread_testcancel();
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_setconcurrency.c b/libc-top-half/musl/src/thread/pthread_setconcurrency.c
new file mode 100644
index 0000000..091abf9
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_setconcurrency.c
@@ -0,0 +1,9 @@
+#include <pthread.h>
+#include <errno.h>
+
+int pthread_setconcurrency(int val)
+{
+	if (val < 0) return EINVAL;
+	if (val > 0) return EAGAIN;
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_setname_np.c b/libc-top-half/musl/src/thread/pthread_setname_np.c
new file mode 100644
index 0000000..fc2d230
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_setname_np.c
@@ -0,0 +1,26 @@
+#define _GNU_SOURCE
+#include <fcntl.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/prctl.h>
+
+#include "pthread_impl.h"
+
+int pthread_setname_np(pthread_t thread, const char *name)
+{
+	int fd, cs, status = 0;
+	char f[sizeof "/proc/self/task//comm" + 3*sizeof(int)];
+	size_t len;
+
+	if ((len = strnlen(name, 16)) > 15) return ERANGE;
+
+	if (thread == pthread_self())
+		return prctl(PR_SET_NAME, (unsigned long)name, 0UL, 0UL, 0UL) ? errno : 0;
+
+	snprintf(f, sizeof f, "/proc/self/task/%d/comm", thread->tid);
+	pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cs);
+	if ((fd = open(f, O_WRONLY|O_CLOEXEC)) < 0 || write(fd, name, len) < 0) status = errno;
+	if (fd >= 0) close(fd);
+	pthread_setcancelstate(cs, 0);
+	return status;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_setschedparam.c b/libc-top-half/musl/src/thread/pthread_setschedparam.c
new file mode 100644
index 0000000..76d4d45
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_setschedparam.c
@@ -0,0 +1,14 @@
+#include "pthread_impl.h"
+#include "lock.h"
+
+int pthread_setschedparam(pthread_t t, int policy, const struct sched_param *param)
+{
+	int r;
+	sigset_t set;
+	__block_app_sigs(&set);
+	LOCK(t->killlock);
+	r = !t->tid ? ESRCH : -__syscall(SYS_sched_setscheduler, t->tid, policy, param);
+	UNLOCK(t->killlock);
+	__restore_sigs(&set);
+	return r;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_setschedprio.c b/libc-top-half/musl/src/thread/pthread_setschedprio.c
new file mode 100644
index 0000000..fc2e13d
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_setschedprio.c
@@ -0,0 +1,14 @@
+#include "pthread_impl.h"
+#include "lock.h"
+
+int pthread_setschedprio(pthread_t t, int prio)
+{
+	int r;
+	sigset_t set;
+	__block_app_sigs(&set);
+	LOCK(t->killlock);
+	r = !t->tid ? ESRCH : -__syscall(SYS_sched_setparam, t->tid, &prio);
+	UNLOCK(t->killlock);
+	__restore_sigs(&set);
+	return r;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_setspecific.c b/libc-top-half/musl/src/thread/pthread_setspecific.c
new file mode 100644
index 0000000..55e46a8
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_setspecific.c
@@ -0,0 +1,12 @@
+#include "pthread_impl.h"
+
+int pthread_setspecific(pthread_key_t k, const void *x)
+{
+	struct pthread *self = __pthread_self();
+	/* Avoid unnecessary COW */
+	if (self->tsd[k] != x) {
+		self->tsd[k] = (void *)x;
+		self->tsd_used = 1;
+	}
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_sigmask.c b/libc-top-half/musl/src/thread/pthread_sigmask.c
new file mode 100644
index 0000000..f188782
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_sigmask.c
@@ -0,0 +1,19 @@
+#include <signal.h>
+#include <errno.h>
+#include "syscall.h"
+
+int pthread_sigmask(int how, const sigset_t *restrict set, sigset_t *restrict old)
+{
+	int ret;
+	if (set && (unsigned)how - SIG_BLOCK > 2U) return EINVAL;
+	ret = -__syscall(SYS_rt_sigprocmask, how, set, old, _NSIG/8);
+	if (!ret && old) {
+		if (sizeof old->__bits[0] == 8) {
+			old->__bits[0] &= ~0x380000000ULL;
+		} else {
+			old->__bits[0] &= ~0x80000000UL;
+			old->__bits[1] &= ~0x3UL;
+		}
+	}
+	return ret;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_spin_destroy.c b/libc-top-half/musl/src/thread/pthread_spin_destroy.c
new file mode 100644
index 0000000..e65a820
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_spin_destroy.c
@@ -0,0 +1,6 @@
+#include "pthread_impl.h"
+
+int pthread_spin_destroy(pthread_spinlock_t *s)
+{
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_spin_init.c b/libc-top-half/musl/src/thread/pthread_spin_init.c
new file mode 100644
index 0000000..681881c
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_spin_init.c
@@ -0,0 +1,6 @@
+#include "pthread_impl.h"
+
+int pthread_spin_init(pthread_spinlock_t *s, int shared)
+{
+	return *s = 0;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_spin_lock.c b/libc-top-half/musl/src/thread/pthread_spin_lock.c
new file mode 100644
index 0000000..ded2b65
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_spin_lock.c
@@ -0,0 +1,8 @@
+#include "pthread_impl.h"
+#include <errno.h>
+
+int pthread_spin_lock(pthread_spinlock_t *s)
+{
+	while (*(volatile int *)s || a_cas(s, 0, EBUSY)) a_spin();
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_spin_trylock.c b/libc-top-half/musl/src/thread/pthread_spin_trylock.c
new file mode 100644
index 0000000..5284fda
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_spin_trylock.c
@@ -0,0 +1,7 @@
+#include "pthread_impl.h"
+#include <errno.h>
+
+int pthread_spin_trylock(pthread_spinlock_t *s)
+{
+	return a_cas(s, 0, EBUSY);
+}
diff --git a/libc-top-half/musl/src/thread/pthread_spin_unlock.c b/libc-top-half/musl/src/thread/pthread_spin_unlock.c
new file mode 100644
index 0000000..724d9e0
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_spin_unlock.c
@@ -0,0 +1,7 @@
+#include "pthread_impl.h"
+
+int pthread_spin_unlock(pthread_spinlock_t *s)
+{
+	a_store(s, 0);
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/pthread_testcancel.c b/libc-top-half/musl/src/thread/pthread_testcancel.c
new file mode 100644
index 0000000..d772449
--- /dev/null
+++ b/libc-top-half/musl/src/thread/pthread_testcancel.c
@@ -0,0 +1,14 @@
+#include "pthread_impl.h"
+
+static void dummy()
+{
+}
+
+weak_alias(dummy, __testcancel);
+
+void __pthread_testcancel()
+{
+	__testcancel();
+}
+
+weak_alias(__pthread_testcancel, pthread_testcancel);
diff --git a/libc-top-half/musl/src/thread/riscv64/__set_thread_area.s b/libc-top-half/musl/src/thread/riscv64/__set_thread_area.s
new file mode 100644
index 0000000..828154d
--- /dev/null
+++ b/libc-top-half/musl/src/thread/riscv64/__set_thread_area.s
@@ -0,0 +1,6 @@
+.global __set_thread_area
+.type   __set_thread_area, %function
+__set_thread_area:
+	mv tp, a0
+	li a0, 0
+	ret
diff --git a/libc-top-half/musl/src/thread/riscv64/__unmapself.s b/libc-top-half/musl/src/thread/riscv64/__unmapself.s
new file mode 100644
index 0000000..2849119
--- /dev/null
+++ b/libc-top-half/musl/src/thread/riscv64/__unmapself.s
@@ -0,0 +1,7 @@
+.global __unmapself
+.type __unmapself, %function
+__unmapself:
+	li a7, 215 # SYS_munmap
+	ecall
+	li a7, 93  # SYS_exit
+	ecall
diff --git a/libc-top-half/musl/src/thread/riscv64/clone.s b/libc-top-half/musl/src/thread/riscv64/clone.s
new file mode 100644
index 0000000..db90824
--- /dev/null
+++ b/libc-top-half/musl/src/thread/riscv64/clone.s
@@ -0,0 +1,34 @@
+# __clone(func, stack, flags, arg, ptid, tls, ctid)
+#           a0,    a1,    a2,  a3,   a4,  a5,   a6
+
+# syscall(SYS_clone, flags, stack, ptid, tls, ctid)
+#                a7     a0,    a1,   a2,  a3,   a4
+
+.global __clone
+.type  __clone, %function
+__clone:
+	# Save func and arg to stack
+	addi a1, a1, -16
+	sd a0, 0(a1)
+	sd a3, 8(a1)
+
+	# Call SYS_clone
+	mv a0, a2
+	mv a2, a4
+	mv a3, a5
+	mv a4, a6
+	li a7, 220 # SYS_clone
+	ecall
+
+	beqz a0, 1f
+	# Parent
+	ret
+
+	# Child
+1:      ld a1, 0(sp)
+	ld a0, 8(sp)
+	jalr a1
+
+	# Exit
+	li a7, 93 # SYS_exit
+	ecall
diff --git a/libc-top-half/musl/src/thread/riscv64/syscall_cp.s b/libc-top-half/musl/src/thread/riscv64/syscall_cp.s
new file mode 100644
index 0000000..eeef639
--- /dev/null
+++ b/libc-top-half/musl/src/thread/riscv64/syscall_cp.s
@@ -0,0 +1,29 @@
+.global __cp_begin
+.hidden __cp_begin
+.global __cp_end
+.hidden __cp_end
+.global __cp_cancel
+.hidden __cp_cancel
+.hidden __cancel
+.global __syscall_cp_asm
+.hidden __syscall_cp_asm
+.type __syscall_cp_asm, %function
+__syscall_cp_asm:
+__cp_begin:
+	lw t0, 0(a0)
+	bnez t0, __cp_cancel
+
+	mv t0, a1
+	mv a0, a2
+	mv a1, a3
+	mv a2, a4
+	mv a3, a5
+	mv a4, a6
+	mv a5, a7
+	ld a6, 0(sp)
+	mv a7, t0
+	ecall
+__cp_end:
+	ret
+__cp_cancel:
+	tail __cancel
diff --git a/libc-top-half/musl/src/thread/s390x/__set_thread_area.s b/libc-top-half/musl/src/thread/s390x/__set_thread_area.s
new file mode 100644
index 0000000..00a11e2
--- /dev/null
+++ b/libc-top-half/musl/src/thread/s390x/__set_thread_area.s
@@ -0,0 +1,10 @@
+.text
+.global __set_thread_area
+.hidden __set_thread_area
+.type   __set_thread_area, %function
+__set_thread_area:
+	sar  %a1, %r2
+	srlg %r2, %r2, 32
+	sar  %a0, %r2
+	lghi %r2, 0
+	br   %r14
diff --git a/libc-top-half/musl/src/thread/s390x/__tls_get_offset.s b/libc-top-half/musl/src/thread/s390x/__tls_get_offset.s
new file mode 100644
index 0000000..8ee92de
--- /dev/null
+++ b/libc-top-half/musl/src/thread/s390x/__tls_get_offset.s
@@ -0,0 +1,17 @@
+	.global __tls_get_offset
+	.type __tls_get_offset,%function
+__tls_get_offset:
+	stmg  %r14, %r15, 112(%r15)
+	aghi  %r15, -160
+
+	la    %r2, 0(%r2, %r12)
+	brasl %r14, __tls_get_addr
+
+	ear   %r1, %a0
+	sllg  %r1, %r1, 32
+	ear   %r1, %a1
+
+	sgr   %r2, %r1
+
+	lmg   %r14, %r15, 272(%r15)
+	br    %r14
diff --git a/libc-top-half/musl/src/thread/s390x/__unmapself.s b/libc-top-half/musl/src/thread/s390x/__unmapself.s
new file mode 100644
index 0000000..48b312c
--- /dev/null
+++ b/libc-top-half/musl/src/thread/s390x/__unmapself.s
@@ -0,0 +1,6 @@
+.text
+.global __unmapself
+.type   __unmapself, @function
+__unmapself:
+	svc 91 # SYS_munmap
+	svc 1  # SYS_exit
diff --git a/libc-top-half/musl/src/thread/s390x/clone.s b/libc-top-half/musl/src/thread/s390x/clone.s
new file mode 100644
index 0000000..2125f20
--- /dev/null
+++ b/libc-top-half/musl/src/thread/s390x/clone.s
@@ -0,0 +1,54 @@
+.text
+.global __clone
+.hidden __clone
+.type __clone, %function
+__clone:
+	# int clone(
+	#    fn,      a = r2
+	#    stack,   b = r3
+	#    flags,   c = r4
+	#    arg,     d = r5
+	#    ptid,    e = r6
+	#    tls,     f = *(r15+160)
+	#    ctid)    g = *(r15+168)
+	#
+	# pseudo C code:
+	# tid = syscall(SYS_clone,b,c,e,g,f);
+	# if (!tid) syscall(SYS_exit, a(d));
+	# return tid;
+
+	# preserve call-saved register used as syscall arg
+	stg  %r6, 48(%r15)
+
+	# create initial stack frame for new thread
+	nill %r3, 0xfff8
+	aghi %r3, -160
+	lghi %r0, 0
+	stg  %r0, 0(%r3)
+
+	# save fn and arg to child stack
+	stg  %r2,  8(%r3)
+	stg  %r5, 16(%r3)
+
+	# shuffle args into correct registers and call SYS_clone
+	lgr  %r2, %r3
+	lgr  %r3, %r4
+	lgr  %r4, %r6
+	lg   %r5, 168(%r15)
+	lg   %r6, 160(%r15)
+	svc  120
+
+	# restore call-saved register
+	lg   %r6, 48(%r15)
+
+	# if error or if we're the parent, return
+	ltgr %r2, %r2
+	bnzr %r14
+
+	# we're the child. call fn(arg)
+	lg   %r1,  8(%r15)
+	lg   %r2, 16(%r15)
+	basr %r14, %r1
+
+	# call SYS_exit. exit code is already in r2 from fn return value
+	svc  1
diff --git a/libc-top-half/musl/src/thread/s390x/syscall_cp.s b/libc-top-half/musl/src/thread/s390x/syscall_cp.s
new file mode 100644
index 0000000..d094cbf
--- /dev/null
+++ b/libc-top-half/musl/src/thread/s390x/syscall_cp.s
@@ -0,0 +1,34 @@
+	.global __cp_begin
+	.hidden __cp_begin
+	.global __cp_end
+	.hidden __cp_end
+	.global __cp_cancel
+	.hidden __cp_cancel
+	.hidden __cancel
+	.global __syscall_cp_asm
+	.hidden __syscall_cp_asm
+	.text
+	.type   __syscall_cp_asm,%function
+__syscall_cp_asm:
+__cp_begin:
+	icm %r2, 15, 0(%r2)
+	jne __cp_cancel
+
+	stg %r6, 48(%r15)
+	stg %r7, 56(%r15)
+	lgr %r1, %r3
+	lgr %r2, %r4
+	lgr %r3, %r5
+	lgr %r4, %r6
+	lg  %r5, 160(%r15)
+	lg  %r6, 168(%r15)
+	lg  %r7, 176(%r15)
+	svc 0
+
+__cp_end:
+	lg  %r7, 56(%r15)
+	lg  %r6, 48(%r15)
+	br  %r14
+
+__cp_cancel:
+	jg  __cancel
diff --git a/libc-top-half/musl/src/thread/sem_destroy.c b/libc-top-half/musl/src/thread/sem_destroy.c
new file mode 100644
index 0000000..f4aced5
--- /dev/null
+++ b/libc-top-half/musl/src/thread/sem_destroy.c
@@ -0,0 +1,6 @@
+#include <semaphore.h>
+
+int sem_destroy(sem_t *sem)
+{
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/sem_getvalue.c b/libc-top-half/musl/src/thread/sem_getvalue.c
new file mode 100644
index 0000000..d9d8307
--- /dev/null
+++ b/libc-top-half/musl/src/thread/sem_getvalue.c
@@ -0,0 +1,8 @@
+#include <semaphore.h>
+
+int sem_getvalue(sem_t *restrict sem, int *restrict valp)
+{
+	int val = sem->__val[0];
+	*valp = val < 0 ? 0 : val;
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/sem_init.c b/libc-top-half/musl/src/thread/sem_init.c
new file mode 100644
index 0000000..5509243
--- /dev/null
+++ b/libc-top-half/musl/src/thread/sem_init.c
@@ -0,0 +1,15 @@
+#include <semaphore.h>
+#include <limits.h>
+#include <errno.h>
+
+int sem_init(sem_t *sem, int pshared, unsigned value)
+{
+	if (value > SEM_VALUE_MAX) {
+		errno = EINVAL;
+		return -1;
+	}
+	sem->__val[0] = value;
+	sem->__val[1] = 0;
+	sem->__val[2] = pshared ? 0 : 128;
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/sem_open.c b/libc-top-half/musl/src/thread/sem_open.c
new file mode 100644
index 0000000..0ad29de
--- /dev/null
+++ b/libc-top-half/musl/src/thread/sem_open.c
@@ -0,0 +1,182 @@
+#include <semaphore.h>
+#include <sys/mman.h>
+#include <limits.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <string.h>
+#include <stdarg.h>
+#include <errno.h>
+#include <time.h>
+#include <stdio.h>
+#include <sys/stat.h>
+#include <stdlib.h>
+#include <pthread.h>
+#include "lock.h"
+#include "fork_impl.h"
+
+#define malloc __libc_malloc
+#define calloc __libc_calloc
+#define realloc undef
+#define free undef
+
+static struct {
+	ino_t ino;
+	sem_t *sem;
+	int refcnt;
+} *semtab;
+static volatile int lock[1];
+volatile int *const __sem_open_lockptr = lock;
+
+#define FLAGS (O_RDWR|O_NOFOLLOW|O_CLOEXEC|O_NONBLOCK)
+
+sem_t *sem_open(const char *name, int flags, ...)
+{
+	va_list ap;
+	mode_t mode;
+	unsigned value;
+	int fd, i, e, slot, first=1, cnt, cs;
+	sem_t newsem;
+	void *map;
+	char tmp[64];
+	struct timespec ts;
+	struct stat st;
+	char buf[NAME_MAX+10];
+
+	if (!(name = __shm_mapname(name, buf)))
+		return SEM_FAILED;
+
+	LOCK(lock);
+	/* Allocate table if we don't have one yet */
+	if (!semtab && !(semtab = calloc(sizeof *semtab, SEM_NSEMS_MAX))) {
+		UNLOCK(lock);
+		return SEM_FAILED;
+	}
+
+	/* Reserve a slot in case this semaphore is not mapped yet;
+	 * this is necessary because there is no way to handle
+	 * failures after creation of the file. */
+	slot = -1;
+	for (cnt=i=0; i<SEM_NSEMS_MAX; i++) {
+		cnt += semtab[i].refcnt;
+		if (!semtab[i].sem && slot < 0) slot = i;
+	}
+	/* Avoid possibility of overflow later */
+	if (cnt == INT_MAX || slot < 0) {
+		errno = EMFILE;
+		UNLOCK(lock);
+		return SEM_FAILED;
+	}
+	/* Dummy pointer to make a reservation */
+	semtab[slot].sem = (sem_t *)-1;
+	UNLOCK(lock);
+
+	flags &= (O_CREAT|O_EXCL);
+
+	pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cs);
+
+	/* Early failure check for exclusive open; otherwise the case
+	 * where the semaphore already exists is expensive. */
+	if (flags == (O_CREAT|O_EXCL) && access(name, F_OK) == 0) {
+		errno = EEXIST;
+		goto fail;
+	}
+
+	for (;;) {
+		/* If exclusive mode is not requested, try opening an
+		 * existing file first and fall back to creation. */
+		if (flags != (O_CREAT|O_EXCL)) {
+			fd = open(name, FLAGS);
+			if (fd >= 0) {
+				if (fstat(fd, &st) < 0 ||
+				    (map = mmap(0, sizeof(sem_t), PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0)) == MAP_FAILED) {
+					close(fd);
+					goto fail;
+				}
+				close(fd);
+				break;
+			}
+			if (errno != ENOENT)
+				goto fail;
+		}
+		if (!(flags & O_CREAT))
+			goto fail;
+		if (first) {
+			first = 0;
+			va_start(ap, flags);
+			mode = va_arg(ap, mode_t) & 0666;
+			value = va_arg(ap, unsigned);
+			va_end(ap);
+			if (value > SEM_VALUE_MAX) {
+				errno = EINVAL;
+				goto fail;
+			}
+			sem_init(&newsem, 1, value);
+		}
+		/* Create a temp file with the new semaphore contents
+		 * and attempt to atomically link it as the new name */
+		clock_gettime(CLOCK_REALTIME, &ts);
+		snprintf(tmp, sizeof(tmp), "/dev/shm/tmp-%d", (int)ts.tv_nsec);
+		fd = open(tmp, O_CREAT|O_EXCL|FLAGS, mode);
+		if (fd < 0) {
+			if (errno == EEXIST) continue;
+			goto fail;
+		}
+		if (write(fd, &newsem, sizeof newsem) != sizeof newsem || fstat(fd, &st) < 0 ||
+		    (map = mmap(0, sizeof(sem_t), PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0)) == MAP_FAILED) {
+			close(fd);
+			unlink(tmp);
+			goto fail;
+		}
+		close(fd);
+		e = link(tmp, name) ? errno : 0;
+		unlink(tmp);
+		if (!e) break;
+		munmap(map, sizeof(sem_t));
+		/* Failure is only fatal when doing an exclusive open;
+		 * otherwise, next iteration will try to open the
+		 * existing file. */
+		if (e != EEXIST || flags == (O_CREAT|O_EXCL))
+			goto fail;
+	}
+
+	/* See if the newly mapped semaphore is already mapped. If
+	 * so, unmap the new mapping and use the existing one. Otherwise,
+	 * add it to the table of mapped semaphores. */
+	LOCK(lock);
+	for (i=0; i<SEM_NSEMS_MAX && semtab[i].ino != st.st_ino; i++);
+	if (i<SEM_NSEMS_MAX) {
+		munmap(map, sizeof(sem_t));
+		semtab[slot].sem = 0;
+		slot = i;
+		map = semtab[i].sem;
+	}
+	semtab[slot].refcnt++;
+	semtab[slot].sem = map;
+	semtab[slot].ino = st.st_ino;
+	UNLOCK(lock);
+	pthread_setcancelstate(cs, 0);
+	return map;
+
+fail:
+	pthread_setcancelstate(cs, 0);
+	LOCK(lock);
+	semtab[slot].sem = 0;
+	UNLOCK(lock);
+	return SEM_FAILED;
+}
+
+int sem_close(sem_t *sem)
+{
+	int i;
+	LOCK(lock);
+	for (i=0; i<SEM_NSEMS_MAX && semtab[i].sem != sem; i++);
+	if (--semtab[i].refcnt) {
+		UNLOCK(lock);
+		return 0;
+	}
+	semtab[i].sem = 0;
+	semtab[i].ino = 0;
+	UNLOCK(lock);
+	munmap(sem, sizeof *sem);
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/sem_post.c b/libc-top-half/musl/src/thread/sem_post.c
new file mode 100644
index 0000000..31e3293
--- /dev/null
+++ b/libc-top-half/musl/src/thread/sem_post.c
@@ -0,0 +1,17 @@
+#include <semaphore.h>
+#include "pthread_impl.h"
+
+int sem_post(sem_t *sem)
+{
+	int val, waiters, priv = sem->__val[2];
+	do {
+		val = sem->__val[0];
+		waiters = sem->__val[1];
+		if (val == SEM_VALUE_MAX) {
+			errno = EOVERFLOW;
+			return -1;
+		}
+	} while (a_cas(sem->__val, val, val+1+(val<0)) != val);
+	if (val<0 || waiters) __wake(sem->__val, 1, priv);
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/sem_timedwait.c b/libc-top-half/musl/src/thread/sem_timedwait.c
new file mode 100644
index 0000000..58d3ebf
--- /dev/null
+++ b/libc-top-half/musl/src/thread/sem_timedwait.c
@@ -0,0 +1,31 @@
+#include <semaphore.h>
+#include "pthread_impl.h"
+
+static void cleanup(void *p)
+{
+	a_dec(p);
+}
+
+int sem_timedwait(sem_t *restrict sem, const struct timespec *restrict at)
+{
+	pthread_testcancel();
+
+	if (!sem_trywait(sem)) return 0;
+
+	int spins = 100;
+	while (spins-- && sem->__val[0] <= 0 && !sem->__val[1]) a_spin();
+
+	while (sem_trywait(sem)) {
+		int r;
+		a_inc(sem->__val+1);
+		a_cas(sem->__val, 0, -1);
+		pthread_cleanup_push(cleanup, (void *)(sem->__val+1));
+		r = __timedwait_cp(sem->__val, -1, CLOCK_REALTIME, at, sem->__val[2]);
+		pthread_cleanup_pop(1);
+		if (r) {
+			errno = r;
+			return -1;
+		}
+	}
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/sem_trywait.c b/libc-top-half/musl/src/thread/sem_trywait.c
new file mode 100644
index 0000000..04edf46
--- /dev/null
+++ b/libc-top-half/musl/src/thread/sem_trywait.c
@@ -0,0 +1,13 @@
+#include <semaphore.h>
+#include "pthread_impl.h"
+
+int sem_trywait(sem_t *sem)
+{
+	int val;
+	while ((val=sem->__val[0]) > 0) {
+		int new = val-1-(val==1 && sem->__val[1]);
+		if (a_cas(sem->__val, val, new)==val) return 0;
+	}
+	errno = EAGAIN;
+	return -1;
+}
diff --git a/libc-top-half/musl/src/thread/sem_unlink.c b/libc-top-half/musl/src/thread/sem_unlink.c
new file mode 100644
index 0000000..c06134b
--- /dev/null
+++ b/libc-top-half/musl/src/thread/sem_unlink.c
@@ -0,0 +1,7 @@
+#include <semaphore.h>
+#include <sys/mman.h>
+
+int sem_unlink(const char *name)
+{
+	return shm_unlink(name);
+}
diff --git a/libc-top-half/musl/src/thread/sem_wait.c b/libc-top-half/musl/src/thread/sem_wait.c
new file mode 100644
index 0000000..264194f
--- /dev/null
+++ b/libc-top-half/musl/src/thread/sem_wait.c
@@ -0,0 +1,6 @@
+#include <semaphore.h>
+
+int sem_wait(sem_t *sem)
+{
+	return sem_timedwait(sem, 0);
+}
diff --git a/libc-top-half/musl/src/thread/sh/__set_thread_area.c b/libc-top-half/musl/src/thread/sh/__set_thread_area.c
new file mode 100644
index 0000000..34264bd
--- /dev/null
+++ b/libc-top-half/musl/src/thread/sh/__set_thread_area.c
@@ -0,0 +1,37 @@
+#include "pthread_impl.h"
+#include "libc.h"
+#include <elf.h>
+
+/* Also perform sh-specific init */
+
+#define CPU_HAS_LLSC 0x0040
+#define CPU_HAS_CAS_L 0x0400
+
+extern hidden const char __sh_cas_gusa[], __sh_cas_llsc[], __sh_cas_imask[], __sh_cas_cas_l[];
+
+hidden const void *__sh_cas_ptr;
+
+hidden unsigned __sh_nommu;
+
+int __set_thread_area(void *p)
+{
+	size_t *aux;
+	__asm__ __volatile__ ( "ldc %0, gbr" : : "r"(p) : "memory" );
+#ifndef __SH4A__
+	__sh_cas_ptr = __sh_cas_gusa;
+#if !defined(__SH3__) && !defined(__SH4__)
+	for (aux=libc.auxv; *aux; aux+=2) {
+		if (*aux != AT_PLATFORM) continue;
+		const char *s = (void *)aux[1];
+		if (s[0]!='s' || s[1]!='h' || s[2]!='2' || s[3]-'0'<10u) break;
+		__sh_cas_ptr = __sh_cas_imask;
+		__sh_nommu = 1;
+	}
+#endif
+	if (__hwcap & CPU_HAS_CAS_L)
+		__sh_cas_ptr = __sh_cas_cas_l;
+	else if (__hwcap & CPU_HAS_LLSC)
+		__sh_cas_ptr = __sh_cas_llsc;
+#endif
+	return 0;
+}
diff --git a/libc-top-half/musl/src/thread/sh/__unmapself.c b/libc-top-half/musl/src/thread/sh/__unmapself.c
new file mode 100644
index 0000000..35fb3c9
--- /dev/null
+++ b/libc-top-half/musl/src/thread/sh/__unmapself.c
@@ -0,0 +1,24 @@
+#include "pthread_impl.h"
+
+hidden void __unmapself_sh_mmu(void *, size_t);
+hidden void __unmapself_sh_nommu(void *, size_t);
+
+#if !defined(__SH3__) && !defined(__SH4__)
+#define __unmapself __unmapself_sh_nommu
+#include "dynlink.h"
+#undef CRTJMP
+#define CRTJMP(pc,sp) __asm__ __volatile__( \
+	"mov.l @%0+,r0 ; mov.l @%0,r12 ; jmp @r0 ; mov %1,r15" \
+	: : "r"(pc), "r"(sp) : "r0", "memory" )
+#include "../__unmapself.c"
+#undef __unmapself
+extern hidden unsigned __sh_nommu;
+#else
+#define __sh_nommu 0
+#endif
+
+void __unmapself(void *base, size_t size)
+{
+	if (__sh_nommu) __unmapself_sh_nommu(base, size);
+	else __unmapself_sh_mmu(base, size);
+}
diff --git a/libc-top-half/musl/src/thread/sh/__unmapself_mmu.s b/libc-top-half/musl/src/thread/sh/__unmapself_mmu.s
new file mode 100644
index 0000000..688087b
--- /dev/null
+++ b/libc-top-half/musl/src/thread/sh/__unmapself_mmu.s
@@ -0,0 +1,23 @@
+.text
+.global __unmapself_sh_mmu
+.hidden __unmapself_sh_mmu
+.type   __unmapself_sh_mmu, @function
+__unmapself_sh_mmu:
+	mov   #91, r3  ! SYS_munmap
+	trapa #31
+
+	or    r0, r0
+	or    r0, r0
+	or    r0, r0
+	or    r0, r0
+	or    r0, r0
+
+	mov   #1, r3   ! SYS_exit
+	mov   #0, r4
+	trapa #31
+
+	or    r0, r0
+	or    r0, r0
+	or    r0, r0
+	or    r0, r0
+	or    r0, r0
diff --git a/libc-top-half/musl/src/thread/sh/atomics.s b/libc-top-half/musl/src/thread/sh/atomics.s
new file mode 100644
index 0000000..9d9fcb6
--- /dev/null
+++ b/libc-top-half/musl/src/thread/sh/atomics.s
@@ -0,0 +1,65 @@
+/* Contract for all versions is same as cas.l r2,r3,@r0
+ * pr and r1 are also clobbered (by jsr & r1 as temp).
+ * r0,r2,r4-r15 must be preserved.
+ * r3 contains result (==r2 iff cas succeeded). */
+
+	.align 2
+.global __sh_cas_gusa
+.hidden __sh_cas_gusa
+__sh_cas_gusa:
+	mov.l r5,@-r15
+	mov.l r4,@-r15
+	mov r0,r4
+	mova 1f,r0
+	mov r15,r1
+	mov #(0f-1f),r15
+0:	mov.l @r4,r5
+	cmp/eq r5,r2
+	bf 1f
+	mov.l r3,@r4
+1:	mov r1,r15
+	mov r5,r3
+	mov r4,r0
+	mov.l @r15+,r4
+	rts
+	 mov.l @r15+,r5
+
+.global __sh_cas_llsc
+.hidden __sh_cas_llsc
+__sh_cas_llsc:
+	mov r0,r1
+	.word 0x00ab /* synco */
+0:	.word 0x0163 /* movli.l @r1,r0 */
+	cmp/eq r0,r2
+	bf 1f
+	mov r3,r0
+	.word 0x0173 /* movco.l r0,@r1 */
+	bf 0b
+	mov r2,r0
+1:	.word 0x00ab /* synco */
+	mov r0,r3
+	rts
+	 mov r1,r0
+
+.global __sh_cas_imask
+.hidden __sh_cas_imask
+__sh_cas_imask:
+	mov r0,r1
+	stc sr,r0
+	mov.l r0,@-r15
+	or #0xf0,r0
+	ldc r0,sr
+	mov.l @r1,r0
+	cmp/eq r0,r2
+	bf 1f
+	mov.l r3,@r1
+1:	ldc.l @r15+,sr
+	mov r0,r3
+	rts
+	 mov r1,r0
+
+.global __sh_cas_cas_l
+.hidden __sh_cas_cas_l
+__sh_cas_cas_l:
+	rts
+	 .word 0x2323 /* cas.l r2,r3,@r0 */
diff --git a/libc-top-half/musl/src/thread/sh/clone.s b/libc-top-half/musl/src/thread/sh/clone.s
new file mode 100644
index 0000000..9cfd862
--- /dev/null
+++ b/libc-top-half/musl/src/thread/sh/clone.s
@@ -0,0 +1,54 @@
+.text
+.global __clone
+.hidden __clone
+.type   __clone, @function
+__clone:
+! incoming: fn stack flags arg ptid tls      ctid
+!           r4 r5    r6    r7  @r15 @(4,r15) @(8,r15)
+
+	mov   #-16, r0
+	and   r0, r5
+
+	mov   r4, r1         ! r1 = fn
+	mov   r7, r2         ! r2 = arg
+
+	mov   #120,     r3   ! r3 = __NR_clone
+	mov   r6,       r4   ! r4 = flags
+	!mov  r5,       r5   ! r5 = stack
+	mov.l @r15,     r6   ! r6 = ptid
+	mov.l @(8,r15), r7   ! r7 = ctid
+	mov.l @(4,r15), r0   ! r0 = tls
+	trapa #31
+
+	or r0, r0
+	or r0, r0
+	or r0, r0
+	or r0, r0
+	or r0, r0
+
+	cmp/eq #0, r0
+	bt     1f
+
+	! we are the parent, return
+	rts
+	 nop
+
+1:	! we are the child, call fn(arg)
+	mov.l  1f, r0
+	mov    r1, r5
+	bsrf   r0
+	 mov    r2, r4
+
+2:	mov   #1, r3   ! __NR_exit
+	mov   r0, r4
+	trapa #31
+
+	or   r0, r0
+	or   r0, r0
+	or   r0, r0
+	or   r0, r0
+	or   r0, r0
+
+.align 2
+.hidden __shcall
+1:	.long __shcall@PCREL+(.-2b)
diff --git a/libc-top-half/musl/src/thread/sh/syscall_cp.s b/libc-top-half/musl/src/thread/sh/syscall_cp.s
new file mode 100644
index 0000000..bb848ef
--- /dev/null
+++ b/libc-top-half/musl/src/thread/sh/syscall_cp.s
@@ -0,0 +1,45 @@
+.text
+.global __cp_begin
+.hidden __cp_begin
+.global __cp_end
+.hidden __cp_end
+.global __cp_cancel
+.hidden __cp_cancel
+.hidden __cancel
+.global __syscall_cp_asm
+.hidden __syscall_cp_asm
+.type   __syscall_cp_asm, @function
+__syscall_cp_asm:
+
+__cp_begin:
+	mov.l @r4, r4
+	tst   r4, r4
+	bf    __cp_cancel
+	mov   r5, r3
+	mov   r6, r4
+	mov   r7, r5
+	mov.l @r15, r6
+	mov.l @(4,r15), r7
+	mov.l @(8,r15), r0
+	mov.l @(12,r15), r1
+	trapa #31
+
+__cp_end:
+	! work around hardware bug
+	or   r0, r0
+	or   r0, r0
+	or   r0, r0
+	or   r0, r0
+	or   r0, r0
+
+	rts
+	 nop
+
+__cp_cancel:
+	mov.l 2f, r0
+	braf  r0
+	 nop
+1:
+
+.align 2
+2:	.long __cancel@PCREL-(1b-.)
diff --git a/libc-top-half/musl/src/thread/synccall.c b/libc-top-half/musl/src/thread/synccall.c
new file mode 100644
index 0000000..d58c851
--- /dev/null
+++ b/libc-top-half/musl/src/thread/synccall.c
@@ -0,0 +1,120 @@
+#include "pthread_impl.h"
+#include <semaphore.h>
+#include <string.h>
+
+static void dummy_0(void)
+{
+}
+
+weak_alias(dummy_0, __tl_lock);
+weak_alias(dummy_0, __tl_unlock);
+
+static int target_tid;
+static void (*callback)(void *), *context;
+static sem_t target_sem, caller_sem;
+
+static void dummy(void *p)
+{
+}
+
+static void handler(int sig)
+{
+	if (__pthread_self()->tid != target_tid) return;
+
+	int old_errno = errno;
+
+	/* Inform caller we have received signal and wait for
+	 * the caller to let us make the callback. */
+	sem_post(&caller_sem);
+	sem_wait(&target_sem);
+
+	callback(context);
+
+	/* Inform caller we've complered the callback and wait
+	 * for the caller to release us to return. */
+	sem_post(&caller_sem);
+	sem_wait(&target_sem);
+
+	/* Inform caller we are returning and state is destroyable. */
+	sem_post(&caller_sem);
+
+	errno = old_errno;
+}
+
+void __synccall(void (*func)(void *), void *ctx)
+{
+	sigset_t oldmask;
+	int cs, i, r;
+	struct sigaction sa = { .sa_flags = SA_RESTART, .sa_handler = handler };
+	pthread_t self = __pthread_self(), td;
+	int count = 0;
+
+	/* Blocking signals in two steps, first only app-level signals
+	 * before taking the lock, then all signals after taking the lock,
+	 * is necessary to achieve AS-safety. Blocking them all first would
+	 * deadlock if multiple threads called __synccall. Waiting to block
+	 * any until after the lock would allow re-entry in the same thread
+	 * with the lock already held. */
+	__block_app_sigs(&oldmask);
+	__tl_lock();
+	__block_all_sigs(0);
+	pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cs);
+
+	sem_init(&target_sem, 0, 0);
+	sem_init(&caller_sem, 0, 0);
+
+	if (!libc.threads_minus_1 || __syscall(SYS_gettid) != self->tid)
+		goto single_threaded;
+
+	callback = func;
+	context = ctx;
+
+	/* Block even implementation-internal signals, so that nothing
+	 * interrupts the SIGSYNCCALL handlers. The main possible source
+	 * of trouble is asynchronous cancellation. */
+	memset(&sa.sa_mask, -1, sizeof sa.sa_mask);
+	__libc_sigaction(SIGSYNCCALL, &sa, 0);
+
+
+	for (td=self->next; td!=self; td=td->next) {
+		target_tid = td->tid;
+		while ((r = -__syscall(SYS_tkill, td->tid, SIGSYNCCALL)) == EAGAIN);
+		if (r) {
+			/* If we failed to signal any thread, nop out the
+			 * callback to abort the synccall and just release
+			 * any threads already caught. */
+			callback = func = dummy;
+			break;
+		}
+		sem_wait(&caller_sem);
+		count++;
+	}
+	target_tid = 0;
+
+	/* Serialize execution of callback in caught threads, or just
+	 * release them all if synccall is being aborted. */
+	for (i=0; i<count; i++) {
+		sem_post(&target_sem);
+		sem_wait(&caller_sem);
+	}
+
+	sa.sa_handler = SIG_IGN;
+	__libc_sigaction(SIGSYNCCALL, &sa, 0);
+
+single_threaded:
+	func(ctx);
+
+	/* Only release the caught threads once all threads, including the
+	 * caller, have returned from the callback function. */
+	for (i=0; i<count; i++)
+		sem_post(&target_sem);
+	for (i=0; i<count; i++)
+		sem_wait(&caller_sem);
+
+	sem_destroy(&caller_sem);
+	sem_destroy(&target_sem);
+
+	pthread_setcancelstate(cs, 0);
+	__tl_unlock();
+	__restore_sigs(&oldmask);
+}
diff --git a/libc-top-half/musl/src/thread/syscall_cp.c b/libc-top-half/musl/src/thread/syscall_cp.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/libc-top-half/musl/src/thread/syscall_cp.c
diff --git a/libc-top-half/musl/src/thread/thrd_create.c b/libc-top-half/musl/src/thread/thrd_create.c
new file mode 100644
index 0000000..76a683d
--- /dev/null
+++ b/libc-top-half/musl/src/thread/thrd_create.c
@@ -0,0 +1,12 @@
+#include "pthread_impl.h"
+#include <threads.h>
+
+int thrd_create(thrd_t *thr, thrd_start_t func, void *arg)
+{
+	int ret = __pthread_create(thr, __ATTRP_C11_THREAD, (void *(*)(void *))func, arg);
+	switch (ret) {
+	case 0:      return thrd_success;
+	case EAGAIN: return thrd_nomem;
+	default:     return thrd_error;
+	}
+}
diff --git a/libc-top-half/musl/src/thread/thrd_exit.c b/libc-top-half/musl/src/thread/thrd_exit.c
new file mode 100644
index 0000000..9b291ae
--- /dev/null
+++ b/libc-top-half/musl/src/thread/thrd_exit.c
@@ -0,0 +1,8 @@
+#include <threads.h>
+#include <pthread.h>
+#include <stdint.h>
+
+_Noreturn void thrd_exit(int result)
+{
+	__pthread_exit((void*)(intptr_t)result);
+}
diff --git a/libc-top-half/musl/src/thread/thrd_join.c b/libc-top-half/musl/src/thread/thrd_join.c
new file mode 100644
index 0000000..0d5fd30
--- /dev/null
+++ b/libc-top-half/musl/src/thread/thrd_join.c
@@ -0,0 +1,11 @@
+#include <stdint.h>
+#include <threads.h>
+#include <pthread.h>
+
+int thrd_join(thrd_t t, int *res)
+{
+        void *pthread_res;
+        __pthread_join(t, &pthread_res);
+        if (res) *res = (int)(intptr_t)pthread_res;
+        return thrd_success;
+}
diff --git a/libc-top-half/musl/src/thread/thrd_sleep.c b/libc-top-half/musl/src/thread/thrd_sleep.c
new file mode 100644
index 0000000..97de534
--- /dev/null
+++ b/libc-top-half/musl/src/thread/thrd_sleep.c
@@ -0,0 +1,14 @@
+#include <threads.h>
+#include <time.h>
+#include <errno.h>
+#include "syscall.h"
+
+int thrd_sleep(const struct timespec *req, struct timespec *rem)
+{
+	int ret = -__clock_nanosleep(CLOCK_REALTIME, 0, req, rem);
+	switch (ret) {
+	case 0:      return 0;
+	case -EINTR: return -1; /* value specified by C11 */
+	default:     return -2;
+	}
+}
diff --git a/libc-top-half/musl/src/thread/thrd_yield.c b/libc-top-half/musl/src/thread/thrd_yield.c
new file mode 100644
index 0000000..f7ad132
--- /dev/null
+++ b/libc-top-half/musl/src/thread/thrd_yield.c
@@ -0,0 +1,7 @@
+#include <threads.h>
+#include "syscall.h"
+
+void thrd_yield()
+{
+	__syscall(SYS_sched_yield);
+}
diff --git a/libc-top-half/musl/src/thread/tls.c b/libc-top-half/musl/src/thread/tls.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/libc-top-half/musl/src/thread/tls.c
diff --git a/libc-top-half/musl/src/thread/tss_create.c b/libc-top-half/musl/src/thread/tss_create.c
new file mode 100644
index 0000000..6d6ef96
--- /dev/null
+++ b/libc-top-half/musl/src/thread/tss_create.c
@@ -0,0 +1,10 @@
+#include <threads.h>
+#include <pthread.h>
+
+int tss_create(tss_t *tss, tss_dtor_t dtor)
+{
+	/* Different error returns are possible. C glues them together into
+	 * just failure notification. Can't be optimized to a tail call,
+	 * unless thrd_error equals EAGAIN. */
+	return __pthread_key_create(tss, dtor) ? thrd_error : thrd_success;
+}
diff --git a/libc-top-half/musl/src/thread/tss_delete.c b/libc-top-half/musl/src/thread/tss_delete.c
new file mode 100644
index 0000000..6f51b07
--- /dev/null
+++ b/libc-top-half/musl/src/thread/tss_delete.c
@@ -0,0 +1,7 @@
+#include <threads.h>
+#include <pthread.h>
+
+void tss_delete(tss_t key)
+{
+	__pthread_key_delete(key);
+}
diff --git a/libc-top-half/musl/src/thread/tss_set.c b/libc-top-half/musl/src/thread/tss_set.c
new file mode 100644
index 0000000..70c4fb7
--- /dev/null
+++ b/libc-top-half/musl/src/thread/tss_set.c
@@ -0,0 +1,13 @@
+#include "pthread_impl.h"
+#include <threads.h>
+
+int tss_set(tss_t k, void *x)
+{
+	struct pthread *self = __pthread_self();
+	/* Avoid unnecessary COW */
+	if (self->tsd[k] != x) {
+		self->tsd[k] = x;
+		self->tsd_used = 1;
+	}
+	return thrd_success;
+}
diff --git a/libc-top-half/musl/src/thread/vmlock.c b/libc-top-half/musl/src/thread/vmlock.c
new file mode 100644
index 0000000..fa0a8e3
--- /dev/null
+++ b/libc-top-half/musl/src/thread/vmlock.c
@@ -0,0 +1,23 @@
+#include "pthread_impl.h"
+#include "fork_impl.h"
+
+static volatile int vmlock[2];
+volatile int *const __vmlock_lockptr = vmlock;
+
+void __vm_wait()
+{
+	int tmp;
+	while ((tmp=vmlock[0]))
+		__wait(vmlock, vmlock+1, tmp, 1);
+}
+
+void __vm_lock()
+{
+	a_inc(vmlock);
+}
+
+void __vm_unlock()
+{
+	if (a_fetch_add(vmlock, -1)==1 && vmlock[1])
+		__wake(vmlock, -1, 1);
+}
diff --git a/libc-top-half/musl/src/thread/x32/__set_thread_area.s b/libc-top-half/musl/src/thread/x32/__set_thread_area.s
new file mode 100644
index 0000000..c0fee87
--- /dev/null
+++ b/libc-top-half/musl/src/thread/x32/__set_thread_area.s
@@ -0,0 +1,11 @@
+/* Copyright 2011-2012 Nicholas J. Kain, licensed under standard MIT license */
+.text
+.global __set_thread_area
+.hidden __set_thread_area
+.type __set_thread_area,@function
+__set_thread_area:
+	mov %edi,%esi           /* shift for syscall */
+	movl $0x1002,%edi       /* SET_FS register */
+	movl $0x4000009e,%eax          /* set fs segment to */
+	syscall                 /* arch_prctl(SET_FS, arg)*/
+	ret
diff --git a/libc-top-half/musl/src/thread/x32/__unmapself.s b/libc-top-half/musl/src/thread/x32/__unmapself.s
new file mode 100644
index 0000000..d925460
--- /dev/null
+++ b/libc-top-half/musl/src/thread/x32/__unmapself.s
@@ -0,0 +1,10 @@
+/* Copyright 2011-2012 Nicholas J. Kain, licensed under standard MIT license */
+.text
+.global __unmapself
+.type   __unmapself,@function
+__unmapself:
+	movl $0x4000000b,%eax   /* SYS_munmap */
+	syscall         /* munmap(arg2,arg3) */
+	xor %rdi,%rdi   /* exit() args: always return success */
+	movl $0x4000003c,%eax   /* SYS_exit */
+	syscall         /* exit(0) */
diff --git a/libc-top-half/musl/src/thread/x32/clone.s b/libc-top-half/musl/src/thread/x32/clone.s
new file mode 100644
index 0000000..b870880
--- /dev/null
+++ b/libc-top-half/musl/src/thread/x32/clone.s
@@ -0,0 +1,26 @@
+.text
+.global __clone
+.hidden __clone
+.type   __clone,@function
+__clone:
+	movl $0x40000038,%eax /* SYS_clone */
+	mov %rdi,%r11
+	mov %rdx,%rdi
+	mov %r8,%rdx
+	mov %r9,%r8
+	mov 8(%rsp),%r10
+	mov %r11,%r9
+	and $-16,%rsi
+	sub $8,%rsi
+	mov %rcx,(%rsi)
+	syscall
+	test %eax,%eax
+	jnz 1f
+	xor %ebp,%ebp
+	pop %rdi
+	call *%r9
+	mov %eax,%edi
+	movl $0x4000003c,%eax /* SYS_exit */
+	syscall
+	hlt
+1:	ret
diff --git a/libc-top-half/musl/src/thread/x32/syscall_cp.s b/libc-top-half/musl/src/thread/x32/syscall_cp.s
new file mode 100644
index 0000000..4f10171
--- /dev/null
+++ b/libc-top-half/musl/src/thread/x32/syscall_cp.s
@@ -0,0 +1,31 @@
+.text
+.global __cp_begin
+.hidden __cp_begin
+.global __cp_end
+.hidden __cp_end
+.global __cp_cancel
+.hidden __cp_cancel
+.hidden __cancel
+.global __syscall_cp_asm
+.hidden __syscall_cp_asm
+.type   __syscall_cp_asm,@function
+__syscall_cp_asm:
+
+__cp_begin:
+	mov (%rdi),%eax
+	test %eax,%eax
+	jnz __cp_cancel
+	mov %rdi,%r11
+	mov %rsi,%rax
+	mov %rdx,%rdi
+	mov %rcx,%rsi
+	mov %r8,%rdx
+	mov %r9,%r10
+	mov 8(%rsp),%r8
+	mov 16(%rsp),%r9
+	mov %r11,8(%rsp)
+	syscall
+__cp_end:
+	ret
+__cp_cancel:
+	jmp __cancel
diff --git a/libc-top-half/musl/src/thread/x86_64/__set_thread_area.s b/libc-top-half/musl/src/thread/x86_64/__set_thread_area.s
new file mode 100644
index 0000000..7347ff4
--- /dev/null
+++ b/libc-top-half/musl/src/thread/x86_64/__set_thread_area.s
@@ -0,0 +1,11 @@
+/* Copyright 2011-2012 Nicholas J. Kain, licensed under standard MIT license */
+.text
+.global __set_thread_area
+.hidden __set_thread_area
+.type __set_thread_area,@function
+__set_thread_area:
+	mov %rdi,%rsi           /* shift for syscall */
+	movl $0x1002,%edi       /* SET_FS register */
+	movl $158,%eax          /* set fs segment to */
+	syscall                 /* arch_prctl(SET_FS, arg)*/
+	ret
diff --git a/libc-top-half/musl/src/thread/x86_64/__unmapself.s b/libc-top-half/musl/src/thread/x86_64/__unmapself.s
new file mode 100644
index 0000000..e2689e6
--- /dev/null
+++ b/libc-top-half/musl/src/thread/x86_64/__unmapself.s
@@ -0,0 +1,10 @@
+/* Copyright 2011-2012 Nicholas J. Kain, licensed under standard MIT license */
+.text
+.global __unmapself
+.type   __unmapself,@function
+__unmapself:
+	movl $11,%eax   /* SYS_munmap */
+	syscall         /* munmap(arg2,arg3) */
+	xor %rdi,%rdi   /* exit() args: always return success */
+	movl $60,%eax   /* SYS_exit */
+	syscall         /* exit(0) */
diff --git a/libc-top-half/musl/src/thread/x86_64/clone.s b/libc-top-half/musl/src/thread/x86_64/clone.s
new file mode 100644
index 0000000..6e47bc0
--- /dev/null
+++ b/libc-top-half/musl/src/thread/x86_64/clone.s
@@ -0,0 +1,28 @@
+.text
+.global __clone
+.hidden __clone
+.type   __clone,@function
+__clone:
+	xor %eax,%eax
+	mov $56,%al
+	mov %rdi,%r11
+	mov %rdx,%rdi
+	mov %r8,%rdx
+	mov %r9,%r8
+	mov 8(%rsp),%r10
+	mov %r11,%r9
+	and $-16,%rsi
+	sub $8,%rsi
+	mov %rcx,(%rsi)
+	syscall
+	test %eax,%eax
+	jnz 1f
+	xor %ebp,%ebp
+	pop %rdi
+	call *%r9
+	mov %eax,%edi
+	xor %eax,%eax
+	mov $60,%al
+	syscall
+	hlt
+1:	ret
diff --git a/libc-top-half/musl/src/thread/x86_64/syscall_cp.s b/libc-top-half/musl/src/thread/x86_64/syscall_cp.s
new file mode 100644
index 0000000..4f10171
--- /dev/null
+++ b/libc-top-half/musl/src/thread/x86_64/syscall_cp.s
@@ -0,0 +1,31 @@
+.text
+.global __cp_begin
+.hidden __cp_begin
+.global __cp_end
+.hidden __cp_end
+.global __cp_cancel
+.hidden __cp_cancel
+.hidden __cancel
+.global __syscall_cp_asm
+.hidden __syscall_cp_asm
+.type   __syscall_cp_asm,@function
+__syscall_cp_asm:
+
+__cp_begin:
+	mov (%rdi),%eax
+	test %eax,%eax
+	jnz __cp_cancel
+	mov %rdi,%r11
+	mov %rsi,%rax
+	mov %rdx,%rdi
+	mov %rcx,%rsi
+	mov %r8,%rdx
+	mov %r9,%r10
+	mov 8(%rsp),%r8
+	mov 16(%rsp),%r9
+	mov %r11,8(%rsp)
+	syscall
+__cp_end:
+	ret
+__cp_cancel:
+	jmp __cancel