add userland thread library. incomplete, but functional

12 files changed, 1589 insertions, 0 deletions

diff --git a/lib/librthread/Makefile b/lib/librthread/Makefile
new file mode 100644
index 00000000000..245106ce583
--- /dev/null
+++ b/lib/librthread/Makefile
@@ -0,0 +1,8 @@
+LIB=rthread
+CFLAGS+=-Wall -g -Werror
+
+.PATH: ${.CURDIR}/arch/${MACHINE_ARCH}
+SRCS= rthread.c rthread_attr.c rthread_sched.c rthread_sync.c rthread_tls.c rthread_sig.c
+OBJS+= _atomic_lock.o rfork_thread.o # .S on alpha
+
+.include <bsd.lib.mk>
diff --git a/lib/librthread/arch/amd64/_atomic_lock.c b/lib/librthread/arch/amd64/_atomic_lock.c
new file mode 100644
index 00000000000..14569edc562
--- /dev/null
+++ b/lib/librthread/arch/amd64/_atomic_lock.c
@@ -0,0 +1,26 @@
+/*	$OpenBSD: _atomic_lock.c,v 1.1 2005/12/03 18:16:19 tedu Exp $	*/
+
+/* David Leonard, <d@csee.uq.edu.au>. Public domain. */
+
+/*
+ * Atomic lock for amd64 -- taken from i386 code.
+ */
+
+#include "spinlock.h"
+
+int
+_atomic_lock(volatile _spinlock_lock_t *lock)
+{
+	_spinlock_lock_t old;
+
+	/*
+	 * Use the eXCHanGe instruction to swap the lock value with
+	 * a local variable containing the locked state.
+	 */
+	old = _SPINLOCK_LOCKED;
+	__asm__("xchg %0,%1"
+		: "=r" (old), "=m" (*lock)
+		: "0"  (old), "1"  (*lock));
+
+	return (old != _SPINLOCK_UNLOCKED);
+}
diff --git a/lib/librthread/arch/amd64/rfork_thread.S b/lib/librthread/arch/amd64/rfork_thread.S
new file mode 100644
index 00000000000..faec9b233c7
--- /dev/null
+++ b/lib/librthread/arch/amd64/rfork_thread.S
@@ -0,0 +1,99 @@
+/*	$OpenBSD: rfork_thread.S,v 1.1 2005/12/03 18:16:19 tedu Exp $ */
+/*-
+ * Copyright (c) 2000 Peter Wemm <peter@FreeBSD.org>
+ * Copyright (c) 2003 Alan L. Cox <alc@cs.rice.edu>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <machine/asm.h>
+#if 0
+__FBSDID("$FreeBSD: /repoman/r/ncvs/src/lib/libc/amd64/gen/rfork_thread.S,v 1.1 2003/10/13 20:32:33 alc Exp $");
+#endif
+
+/*
+ * With thanks to John Dyson for the original version of this.
+ */
+
+#include "../../../libc/arch/amd64/SYS.h"
+
+/*
+ *              %edi   %rsi        %rdx       %rcx
+ * rfork_thread(flags, stack_addr, start_fnc, start_arg);
+ *
+ * flags:		Flags to rfork system call.  See rfork(2).
+ * stack_addr:		Top of stack for thread.
+ * start_fnc:		Address of thread function to call in child.
+ * start_arg:		Argument to pass to the thread function in child.
+ */
+
+ENTRY(rfork_thread)
+	pushq	%rbx
+	pushq	%r12
+	movq	%rdx, %rbx
+	movq	%rcx, %r12
+
+	/*
+	 * Prepare and execute the thread creation syscall
+	 */
+	movq	$SYS_rfork, %rax
+	int	$0x80
+	jb 	2f
+
+	/*
+	 * Check to see if we are in the parent or child
+	 */
+	cmpl	$0, %edx
+	jnz	1f
+	popq	%r12
+	popq	%rbx
+	ret
+
+	/*
+	 * If we are in the child (new thread), then
+	 * set-up the call to the internal subroutine.  If it
+	 * returns, then call __exit.
+	 */
+1:
+	movq	%rsi, %rsp
+	movq	%r12, %rdi 
+	call	*%rbx
+	movl	%eax, %edi
+
+	/*
+	 * Exit system call
+	 */
+#ifdef SYS_exit
+	movq	$SYS_exit, %rax
+#else
+	movq	$SYS_sys_exit, %rax
+#endif
+	int	$0x80
+
+	/*
+	 * Branch here if the thread creation fails:
+	 */
+2:
+	popq	%r12
+	popq	%rbx
+	jmp	CERROR
diff --git a/lib/librthread/arch/i386/_atomic_lock.c b/lib/librthread/arch/i386/_atomic_lock.c
new file mode 100644
index 00000000000..7b9b46a73c7
--- /dev/null
+++ b/lib/librthread/arch/i386/_atomic_lock.c
@@ -0,0 +1,25 @@
+/*	$OpenBSD: _atomic_lock.c,v 1.1 2005/12/03 18:16:19 tedu Exp $	*/
+/* David Leonard, <d@csee.uq.edu.au>. Public domain. */
+
+/*
+ * Atomic lock for i386
+ */
+
+#include <machine/spinlock.h>
+
+int
+_atomic_lock(register volatile _spinlock_lock_t *lock)
+{
+	register _spinlock_lock_t old;
+
+	/*
+	 * Use the eXCHanGe instruction to swap the lock value with
+	 * a local variable containing the locked state.
+	 */
+	old = _SPINLOCK_LOCKED;
+	__asm__("xchg %0,%1"
+		: "=r" (old), "=m" (*lock)
+		: "0"  (old), "1"  (*lock));
+
+	return (old != _SPINLOCK_UNLOCKED);
+}
diff --git a/lib/librthread/arch/i386/rfork_thread.S b/lib/librthread/arch/i386/rfork_thread.S
new file mode 100644
index 00000000000..39e35ac67c2
--- /dev/null
+++ b/lib/librthread/arch/i386/rfork_thread.S
@@ -0,0 +1,126 @@
+/*	$OpenBSD: rfork_thread.S,v 1.1 2005/12/03 18:16:19 tedu Exp $ */
+/*-
+ * Copyright (c) 2000 Peter Wemm <peter@FreeBSD.org>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <machine/asm.h>
+#if 0
+__FBSDID("$FreeBSD: /repoman/r/ncvs/src/lib/libc/i386/gen/rfork_thread.S,v 1.5 2003/05/07 17:23:25 jhb Exp $");
+#endif
+
+/*
+ * With thanks to John Dyson for the original version of this.
+ */
+
+#include "../../../libc/arch/i386/SYS.h"
+
+/*
+ *                8      12          16         20
+ * rfork_thread(flags, stack_addr, start_fnc, start_arg);
+ *
+ * flags:		Flags to rfork system call.  See rfork(2).
+ * stack_addr:		Top of stack for thread.
+ * start_fnc:		Address of thread function to call in child.
+ * start_arg:		Argument to pass to the thread function in child.
+ */
+
+ENTRY(rfork_thread)
+	pushl	%ebp
+	movl	%esp, %ebp
+	pushl	%esi
+
+	/*
+	 * Push thread info onto the new thread's stack
+	 */
+	movl	12(%ebp), %esi	# get stack addr
+
+	subl	$4, %esi
+	movl	20(%ebp), %eax	# get start argument
+	movl	%eax, (%esi)
+
+	subl	$4, %esi
+	movl	16(%ebp), %eax	# get start thread address
+	movl	%eax, (%esi)
+
+	/*
+	 * Prepare and execute the thread creation syscall
+	 */
+	pushl	8(%ebp)
+	pushl	$0
+	movl	$SYS_rfork, %eax
+	int	$0x80
+#if 0
+	jb 	2f
+#endif
+
+	/*
+	 * Check to see if we are in the parent or child
+	 */
+	cmpl	$0, %edx
+	jnz	1f
+	addl	$8, %esp
+	popl	%esi
+	movl	%ebp, %esp
+	popl	%ebp
+	ret
+	.p2align 2
+
+	/*
+	 * If we are in the child (new thread), then
+	 * set-up the call to the internal subroutine.  If it
+	 * returns, then call __exit.
+	 */
+1:
+	movl	%esi,%esp
+	popl	%eax 
+	call	*%eax
+	addl	$4, %esp
+
+	/*
+	 * Exit system call
+	 */
+	pushl	%eax
+	pushl	$0
+#ifdef SYS_exit
+	movl	$SYS_exit, %eax
+#else
+	movl	$SYS_sys_exit, %eax
+#endif
+	int	$0x80
+
+	/*
+	 * Branch here if the thread creation fails:
+	 */
+2:
+	addl	$8, %esp
+	popl	%esi
+	movl	%ebp, %esp
+	popl	%ebp
+#if 0
+	/* FreeBSD code.  how to translate? */
+	PIC_PROLOGUE
+	jmp	PIC_PLT(HIDENAME(cerror))
+#endif
+	jmp	CERROR
diff --git a/lib/librthread/rthread.c b/lib/librthread/rthread.c
new file mode 100644
index 00000000000..7e3cc057c7b
--- /dev/null
+++ b/lib/librthread/rthread.c
@@ -0,0 +1,265 @@
+/*	$OpenBSD: rthread.c,v 1.1 2005/12/03 18:16:19 tedu Exp $ */
+/*
+ * Copyright (c) 2004 Ted Unangst <tedu@openbsd.org>
+ * All Rights Reserved.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+/*
+ * The heart of rthreads.  Basic functions like creating and joining
+ * threads.
+ */
+
+#include <sys/param.h>
+#include <sys/mman.h>
+#include <sys/wait.h>
+
+#include <machine/spinlock.h>
+
+#include <stdlib.h>
+#include <unistd.h>
+#include <signal.h>
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+
+#include <pthread.h>
+
+#include "rthread.h"
+
+static int threads_ready;
+static pthread_t thread_list;
+static _spinlock_lock_t thread_lock;
+
+int yield();
+int getthrid();
+void threxit(int);
+int rfork_thread(int, void *, void (*)(void *), void *);
+
+/*
+ * internal support functions
+ */
+void
+_spinlock(_spinlock_lock_t *lock)
+{
+
+	while (_atomic_lock(lock))
+		pthread_yield();
+}
+
+void
+_spinunlock(_spinlock_lock_t *lock)
+{
+
+	*lock = _SPINLOCK_UNLOCKED;
+}
+
+static pthread_t
+thread_findself(void)
+{
+	pthread_t me;
+	pid_t tid = getthrid();
+
+	for (me = thread_list; me; me = me->next)
+		if (me->tid == tid)
+			break;
+
+	return (me);
+}
+
+
+static void
+thread_start(void *v)
+{
+	pthread_t thread = v;
+	void *retval;
+
+	/* ensure parent returns from rfork, sets up tid */
+	_spinlock(&thread_lock);
+	_spinunlock(&thread_lock);
+	retval = thread->fn(thread->arg);
+	pthread_exit(retval);
+}
+
+static void
+thread_init(void)
+{
+	pthread_t thread;
+	extern int __isthreaded;
+
+	__isthreaded = 1;
+
+	thread = malloc(sizeof(*thread));
+	memset(thread, 0, sizeof(*thread));
+	thread->tid = getthrid();
+	snprintf(thread->name, sizeof(thread->name), "Main process");
+	thread_list = thread;
+	threads_ready = 1;
+}
+
+static struct stack *
+alloc_stack(size_t len)
+{
+	struct stack *stack;
+
+	stack = malloc(sizeof(*stack));
+	stack->base = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_ANON, -1, 0);
+	stack->sp = (void *)(((size_t)stack->base + len - 16) & ~15);
+	return (stack);
+}
+
+
+/*
+ * real pthread functions
+ */
+pthread_t
+pthread_self(void)
+{
+	pthread_t thread;
+
+	if (!threads_ready)
+		thread_init();
+
+	_spinlock(&thread_lock);
+	thread = thread_findself();
+	_spinunlock(&thread_lock);
+
+	return (thread);
+}
+
+void
+pthread_exit(void *retval)
+{
+	pthread_t thread = pthread_self();
+
+	thread->retval = retval;
+	thread->flags |= THREAD_DONE;
+	_sem_wakeup(&thread->donesem);
+#if 0
+	if (thread->flags & THREAD_DETACHED)
+		free(thread);
+#endif
+	threxit(0);
+	for(;;);
+}
+
+int
+pthread_join(pthread_t thread, void **retval)
+{
+
+	_sem_wait(&thread->donesem, 0, 0);
+	printf("joined %d %p\n", thread->tid, thread->retval);
+	if (retval)
+		*retval = thread->retval;
+
+	return (0);
+}
+
+int
+pthread_detach(pthread_t thread)
+{
+	_spinlock(&thread_lock);
+#if 0
+	if (thread->flags & THREAD_DONE)
+		free(thread);
+	else
+#endif
+		thread->flags |= THREAD_DETACHED;
+	_spinunlock(&thread_lock);
+	return (0);
+}
+
+int
+pthread_create(pthread_t *threadp, const pthread_attr_t *attr,
+    void *(*start_routine)(void *), void *arg)
+{
+	pthread_t thread;
+	pid_t tid;
+
+	if (!threads_ready)
+		thread_init();
+
+	thread = malloc(sizeof(*thread));
+	memset(thread, 0, sizeof(*thread));
+	thread->fn = start_routine;
+	thread->arg = arg;
+
+	_spinlock(&thread_lock);
+	thread->next = thread_list;
+	thread_list = thread;
+
+	thread->stack = alloc_stack(64 * 1024);
+
+	tid = rfork_thread(RFPROC | RFTHREAD | RFMEM | RFNOWAIT,
+	    thread->stack->sp, thread_start, thread);
+	/* new thread will appear thread_start */
+	thread->tid = tid;
+	printf("new thread %d\n", tid);
+	*threadp = thread;
+	_spinunlock(&thread_lock);
+
+	return (0);
+}
+
+int
+pthread_equal(pthread_t t1, pthread_t t2)
+{
+	return (t1 == t2);
+}
+
+/*
+ * _np functions
+ */
+void
+pthread_set_name_np(pthread_t thread, char *name)
+{
+	strlcpy(thread->name, name, sizeof(thread->name));
+}
+
+/*
+ * compat debug stuff
+ */
+void
+_thread_dump_info(void)
+{
+	pthread_t thread;
+
+	_spinlock(&thread_lock);
+	for (thread = thread_list; thread; thread = thread->next)
+		printf("thread %d flags %d name %s\n",
+		    thread->tid, thread->flags, thread->name);
+	_spinunlock(&thread_lock);
+}
+
+
+/*
+ * the malloc lock
+ */
+static _spinlock_lock_t malloc_lock;
+
+void
+_thread_malloc_lock()
+{
+	_spinlock(&malloc_lock);
+}
+
+void
+_thread_malloc_unlock()
+{
+	_spinunlock(&malloc_lock);
+}
+
+void
+_thread_malloc_init()
+{
+}
diff --git a/lib/librthread/rthread.h b/lib/librthread/rthread.h
new file mode 100644
index 00000000000..3deec5835d5
--- /dev/null
+++ b/lib/librthread/rthread.h
@@ -0,0 +1,111 @@
+/*	$OpenBSD: rthread.h,v 1.1 2005/12/03 18:16:19 tedu Exp $ */
+/*
+ * Copyright (c) 2004 Ted Unangst <tedu@openbsd.org>
+ * All Rights Reserved.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+/*
+ * Private data structures that back up the typedefs in pthread.h.
+ * Since only the thread library cares about their size or arrangement,
+ * it should be possible to switch libraries without relinking.
+ */
+
+struct stack {
+	void *sp;
+	void *base;
+	size_t len;
+};
+
+typedef struct semaphore {
+	volatile int waitcount;
+	volatile int value;
+	_spinlock_lock_t lock;
+} *sem_t;
+
+struct pthread_mutex {
+	struct semaphore sem;
+	int type;
+	pthread_t owner;
+	int count;
+};
+
+struct pthread_mutex_attr {
+	int type;
+};
+
+struct pthread_cond {
+	struct semaphore sem;
+};
+
+struct pthread_cond_attr {
+	int shared;
+};
+
+struct pthread_rwlock {
+	_spinlock_lock_t lock;
+	int readers;
+	int writer;
+	struct semaphore sem;
+};
+
+struct pthread_rwlockattr {
+	int dummy;
+};
+
+struct pthread_attr {
+	size_t stack_size;
+	int detach_state;
+	int contention_scope;
+	int sched_policy;
+	struct sched_param sched_param;
+	int sched_inherit;
+};
+
+struct rthread_key {
+	int keyid;
+	struct rthread_key *next;
+	void (*destructor)(void *);
+};
+
+struct rthread_storage {
+	int keyid;
+	struct rthread_storage *next;
+	void *data;
+};
+
+struct pthread {
+	pid_t tid;
+	struct semaphore donesem;
+	int flags;
+	void *retval;
+	void *(*fn)(void *);
+	void *arg;
+	char name[32];
+	struct stack *stack;
+	pthread_t next;
+	int sched_policy;
+	struct sched_param sched_param;
+	struct rthread_storage *local_storage;
+	int sigpend;
+};
+#define	THREAD_DONE	0x001
+#define	THREAD_DETACHED	0x002
+
+void	_spinlock(_spinlock_lock_t *);
+void	_spinunlock(_spinlock_lock_t *);
+int	_sem_wait(sem_t, int, int);
+int	_sem_wakeup(sem_t);
+int	_sem_wakeall(sem_t);
+
+int	_atomic_lock(register volatile _spinlock_lock_t *);
diff --git a/lib/librthread/rthread_attr.c b/lib/librthread/rthread_attr.c
new file mode 100644
index 00000000000..532a53d0f17
--- /dev/null
+++ b/lib/librthread/rthread_attr.c
@@ -0,0 +1,109 @@
+/*	$OpenBSD: rthread_attr.c,v 1.1 2005/12/03 18:16:19 tedu Exp $ */
+/*
+ * Copyright (c) 2004 Ted Unangst <tedu@openbsd.org>
+ * All Rights Reserved.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+/*
+ * generic attribute support
+ */
+
+#include <sys/param.h>
+#include <sys/mman.h>
+#include <sys/wait.h>
+
+#include <machine/spinlock.h>
+
+#include <stdlib.h>
+#include <unistd.h>
+#include <signal.h>
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+
+#include <pthread.h>
+
+#include "rthread.h"
+
+int
+pthread_attr_init(pthread_attr_t *attrp)
+{
+	pthread_attr_t attr;
+
+	attr = malloc(sizeof(*attr));
+	if (!attr)
+		return (errno);
+	memset(attr, 0, sizeof(*attr));
+	*attrp = attr;
+
+	return (0);
+}
+
+int
+pthread_attr_destroy(pthread_attr_t *attrp)
+{
+	free(*attrp);
+	*attrp = NULL;
+
+	return (0);
+}
+
+int
+pthread_attr_getdetachstate(const pthread_attr_t *attrp, int *detachstate)
+{
+	*detachstate = (*attrp)->detach_state;
+
+	return (0);
+}
+
+int
+pthread_attr_setdetachstate(pthread_attr_t *attrp, int detachstate)
+{
+	(*attrp)->detach_state = detachstate;
+
+	return (0);
+}
+
+int
+pthread_attr_getstacksize(const pthread_attr_t *attrp, size_t *stacksize)
+{
+	*stacksize = (*attrp)->stack_size;
+
+	return (0);
+
+}
+
+int
+pthread_attr_setstacksize(pthread_attr_t *attrp, size_t stacksize)
+{
+	(*attrp)->stack_size = stacksize;
+
+	return (0);
+}
+
+int
+pthread_attr_getscope(const pthread_attr_t *attrp, int *contentionscope)
+{
+	*contentionscope = (*attrp)->contention_scope;
+
+	return (0);
+}
+
+int
+pthread_attr_setscope(pthread_attr_t *attrp, int contentionscope)
+{
+	(*attrp)->contention_scope = contentionscope;
+
+	return (0);
+}
diff --git a/lib/librthread/rthread_sched.c b/lib/librthread/rthread_sched.c
new file mode 100644
index 00000000000..3ca3113c483
--- /dev/null
+++ b/lib/librthread/rthread_sched.c
@@ -0,0 +1,136 @@
+/*	$OpenBSD: rthread_sched.c,v 1.1 2005/12/03 18:16:19 tedu Exp $ */
+/*
+ * Copyright (c) 2004 Ted Unangst <tedu@openbsd.org>
+ * All Rights Reserved.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+/*
+ * scheduling routines
+ */
+
+#include <sys/param.h>
+#include <sys/mman.h>
+#include <sys/wait.h>
+
+#include <machine/spinlock.h>
+
+#include <stdlib.h>
+#include <unistd.h>
+#include <signal.h>
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+
+#include <pthread.h>
+
+#include "rthread.h"
+
+int yield(void);
+
+int
+pthread_getschedparam(pthread_t thread, int *policy,
+    struct sched_param *param)
+{
+	*policy = thread->sched_policy;
+	if (param)
+		*param = thread->sched_param;
+
+	return (0);
+}
+
+int
+pthread_setschedparam(pthread_t thread, int policy,
+    const struct sched_param *param)
+{
+	thread->sched_policy = policy;
+	if (param)
+		thread->sched_param = *param;
+
+	return (0);
+}
+
+int
+pthread_attr_getschedparam(const pthread_attr_t *attrp, struct sched_param *param)
+{
+	*param = (*attrp)->sched_param;
+
+	return (0);
+}
+
+int
+pthread_attr_setschedparam(pthread_attr_t *attrp, const struct sched_param *param)
+{
+	(*attrp)->sched_param = *param;
+
+	return (0);
+}
+
+int
+pthread_attr_getschedpolicy(const pthread_attr_t *attrp, int *policy)
+{
+	*policy = (*attrp)->sched_policy;
+
+	return (0);
+}
+
+int
+pthread_attr_setschedpolicy(pthread_attr_t *attrp, int policy)
+{
+	(*attrp)->sched_policy = policy;
+
+	return (0);
+}
+
+int
+pthread_attr_getinheritsched(const pthread_attr_t *attrp, int *inherit)
+{
+	*inherit = (*attrp)->sched_inherit;
+
+	return (0);
+}
+
+int
+pthread_attr_setinheritsched(pthread_attr_t *attrp, int inherit)
+{
+	(*attrp)->sched_inherit = inherit;
+
+	return (0);
+}
+
+int
+pthread_getprio(pthread_t thread)
+{
+	return (thread->sched_param.sched_priority);
+}
+
+int
+pthread_setprio(pthread_t thread, int priority)
+{
+	thread->sched_param.sched_priority = priority;
+
+	return (0);
+}
+
+void
+pthread_yield(void)
+{
+	yield();
+}
+int
+sched_yield(void)
+{
+	yield();
+
+	return (0);
+}
diff --git a/lib/librthread/rthread_sig.c b/lib/librthread/rthread_sig.c
new file mode 100644
index 00000000000..5fcb9002e86
--- /dev/null
+++ b/lib/librthread/rthread_sig.c
@@ -0,0 +1,90 @@
+/*	$OpenBSD: rthread_sig.c,v 1.1 2005/12/03 18:16:19 tedu Exp $ */
+/*
+ * Copyright (c) 2004 Ted Unangst <tedu@openbsd.org>
+ * All Rights Reserved.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+/*
+ * signals
+ */
+
+#include <sys/param.h>
+#include <sys/mman.h>
+#include <sys/wait.h>
+
+#include <machine/spinlock.h>
+
+#include <stdlib.h>
+#include <unistd.h>
+#include <signal.h>
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+
+#include <pthread.h>
+
+#include "rthread.h"
+
+int thrwakeup(long);
+int thrsleep(long, int, void *);
+int thrsigdivert(const sigset_t *);
+
+int
+pthread_sigmask(int how, const sigset_t *set, sigset_t *oset)
+{
+	return (sigprocmask(how, set, oset));
+}
+
+/* 
+ * implementation of sigwait:
+ * 1.  we install a handler for each masked signal.
+ * 2.  we inform the kernel we are interested in this signal set.
+ * 3.  sleep.  the handler will wake us up.
+ *
+ * this is atomic because the kernel will only divert one signal
+ * to a thread until it asks for more.
+ */
+static void
+sigwait_handler(int sig)
+{
+	pthread_t self = pthread_self();
+	self->sigpend = sig;
+	thrwakeup((long)&self->sigpend);
+}
+
+typedef void (*sigfn)(int);
+
+int
+sigwait(const sigset_t *set, int *sig)
+{
+	int i;
+	sigset_t mask = *set;
+	pthread_t self = pthread_self();
+	sigfn oldhandlers[NSIG];
+
+	for (i = 0; i < NSIG; i++) {
+		if (mask & (1 << i))
+			oldhandlers[i] = signal(i, sigwait_handler);
+	}
+
+	thrsigdivert(set);
+	thrsleep((long)&self->sigpend, 0, NULL);
+
+	for (i = 0; i < NSIG; i++) {
+		if (mask & (1 << i))
+			signal(i, oldhandlers[i]);
+	}
+	*sig = self->sigpend;
+	return (0);
+}
diff --git a/lib/librthread/rthread_sync.c b/lib/librthread/rthread_sync.c
new file mode 100644
index 00000000000..a2d7faf01cd
--- /dev/null
+++ b/lib/librthread/rthread_sync.c
@@ -0,0 +1,477 @@
+/*	$OpenBSD: rthread_sync.c,v 1.1 2005/12/03 18:16:19 tedu Exp $ */
+/*
+ * Copyright (c) 2004 Ted Unangst <tedu@openbsd.org>
+ * All Rights Reserved.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+/*
+ * Mutexes, conditions, rwlocks, and semaphores - synchronization functions.
+ */
+
+
+#include <sys/param.h>
+#include <sys/mman.h>
+#include <sys/wait.h>
+
+#include <machine/spinlock.h>
+
+#include <stdlib.h>
+#include <unistd.h>
+#include <signal.h>
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+
+#include <pthread.h>
+
+#include "rthread.h"
+
+int thrsleep(long, int, void *);
+int thrwakeup(long);
+
+/*
+ * Internal implementation of semaphores
+ */
+int
+_sem_wait(sem_t sem, int tryonly, int timo)
+{
+	int sleep;
+
+	_spinlock(&sem->lock);
+again:
+	if (sem->value == 0) {
+		if (tryonly) {
+			_spinunlock(&sem->lock);
+			return (0);
+		}
+		sem->waitcount++;
+		sleep = 1;
+	} else {
+		sem->value--;
+		sleep = 0;
+	}
+
+	if (sleep) {
+		if (thrsleep((long)sem, timo, &sem->lock) == EWOULDBLOCK)
+			return (0);
+		_spinlock(&sem->lock);
+		sem->waitcount--;
+		goto again;
+	}
+	_spinunlock(&sem->lock);
+	return (1);
+}
+
+int
+_sem_wakeup(sem_t sem)
+{
+	int rv = 0;
+
+	_spinlock(&sem->lock);
+	sem->value++;
+	if (sem->waitcount) {
+		thrwakeup((long)sem);
+		rv = 1;
+	}
+	_spinunlock(&sem->lock);
+	return (rv);
+}
+
+int
+_sem_wakeall(sem_t sem)
+{
+	int rv;
+
+	_spinlock(&sem->lock);
+	rv = sem->waitcount;
+	sem->value += rv;
+	thrwakeup((long)sem);
+	_spinunlock(&sem->lock);
+
+	return (rv);
+}
+
+/*
+ * mutexen
+ */
+int
+pthread_mutex_init(pthread_mutex_t *mutexp, const pthread_mutexattr_t *attr)
+{
+	pthread_mutex_t mutex;
+
+	mutex = malloc(sizeof(*mutex));
+	if (!mutex)
+		return (errno);
+	memset((void *)mutex, 0, sizeof(*mutex));
+	mutex->sem.value = 1;	/* unlocked */
+	mutex->type = attr ? (*attr)->type : PTHREAD_MUTEX_ERRORCHECK;
+	*mutexp = mutex;
+
+	return (0);
+}
+
+int
+pthread_mutex_destroy(pthread_mutex_t *mutexp)
+{
+
+	/* check for waiters */
+	free((void *)*mutexp);
+	*mutexp = NULL;
+	return (0);
+}
+
+int
+rthread_mutex_lock(pthread_mutex_t *mutexp, int trywait)
+{
+	pthread_mutex_t mutex = *mutexp;
+	pthread_t thread = pthread_self();
+
+	if (!mutex) {
+		pthread_mutex_init(mutexp, NULL);
+		mutex = *mutexp;
+	}
+	if (mutex->owner == thread) {
+		if (mutex->type == PTHREAD_MUTEX_RECURSIVE) {
+			mutex->count++;
+			return (0);
+		}
+		if (mutex->type == PTHREAD_MUTEX_ERRORCHECK)
+			return (EDEADLK);
+	}
+	if (!_sem_wait((void *)&mutex->sem, trywait, 0))
+		return (EBUSY);
+	mutex->owner = thread;
+	mutex->count = 1;
+
+	return (0);
+}
+
+int
+pthread_mutex_lock(pthread_mutex_t *p)
+{
+	return (rthread_mutex_lock(p, 0));
+}
+
+int
+pthread_mutex_trylock(pthread_mutex_t *p)
+{
+	return (rthread_mutex_lock(p, 1));
+}
+
+int
+pthread_mutex_unlock(pthread_mutex_t *mutexp)
+{
+	pthread_t thread = pthread_self();
+	pthread_mutex_t mutex = *mutexp;
+
+	if (mutex->owner != thread)
+		return (EPERM);
+
+	if (--mutex->count == 0) {
+		mutex->owner = NULL;
+		_sem_wakeup((void *)&mutex->sem);
+	}
+
+	return (0);
+}
+
+/*
+ * mutexen attributes
+ */
+int
+pthread_mutexattr_init(pthread_mutexattr_t *attrp)
+{
+	pthread_mutexattr_t attr;
+
+	attr = malloc(sizeof(*attr));
+	if (!attr)
+		return (errno);
+	memset(attr, 0, sizeof(*attr));
+	attr->type = PTHREAD_MUTEX_ERRORCHECK;
+	*attrp = attr;
+
+	return (0);
+}
+
+int
+pthread_mutexattr_destroy(pthread_mutexattr_t *attrp)
+{
+	free(*attrp);
+	*attrp = NULL;
+
+	return (0);
+}
+
+int
+pthread_mutexattr_settype(pthread_mutexattr_t *attrp, int type)
+{
+	(*attrp)->type = type;
+
+	return (0);
+}
+
+/*
+ * condition variables
+ */
+int
+pthread_cond_init(pthread_cond_t *condp, const pthread_condattr_t *attrp)
+{
+	pthread_cond_t cond;
+
+	cond = malloc(sizeof(*cond));
+	if (!cond)
+		return (errno);
+	memset(cond, 0, sizeof(*cond));
+
+	*condp = cond;
+
+	return (0);
+}
+
+int
+pthread_cond_destroy(pthread_cond_t *condp)
+{
+
+	free(*condp);
+	*condp = NULL;
+
+	return (0);
+}
+
+int
+pthread_cond_timedwait(pthread_cond_t *condp, pthread_mutex_t *mutexp,
+    const struct timespec *abstime)
+{
+	int error;
+
+	if (!*condp)
+		if ((error = pthread_cond_init(condp, NULL)))
+			return (error);
+
+	pthread_mutex_unlock(mutexp);
+	_sem_wait(&(*condp)->sem, 0, (abstime ?
+	    abstime->tv_sec * 100 + abstime->tv_nsec / 10000000 : 0));
+	error = pthread_mutex_lock(mutexp);
+
+	return (error);
+}
+
+int
+pthread_cond_wait(pthread_cond_t *condp, pthread_mutex_t *mutexp)
+{
+	return (pthread_cond_timedwait(condp, mutexp, NULL));
+}
+
+int
+pthread_cond_signal(pthread_cond_t *condp)
+{
+	int error;
+
+	if (!*condp)
+		if ((error = pthread_cond_init(condp, NULL)))
+			return (error);
+
+	_sem_wakeup(&(*condp)->sem);
+
+	return (0);
+}
+
+int
+pthread_cond_broadcast(pthread_cond_t *condp)
+{
+	if (!*condp)
+		pthread_cond_init(condp, NULL);
+
+	_sem_wakeall(&(*condp)->sem);
+
+	return (0);
+}
+
+/*
+ * condition variable attributes
+ */
+int
+pthread_condattr_init(pthread_condattr_t *attrp)
+{
+	pthread_condattr_t attr;
+
+	attr = malloc(sizeof(*attr));
+	if (!attr)
+		return (errno);
+	memset(attr, 0, sizeof(*attr));
+	*attrp = attr;
+
+	return (0);
+}
+
+int
+pthread_condattr_destroy(pthread_condattr_t *attrp)
+{
+	free(*attrp);
+	*attrp = NULL;
+
+	return (0);
+}
+
+/*
+ * rwlocks
+ */
+int
+pthread_rwlock_init(pthread_rwlock_t *lockp, const pthread_rwlockattr_t *attrp)
+{
+	pthread_rwlock_t lock;
+
+	lock = malloc(sizeof(*lock));
+	if (!lock)
+		return (errno);
+	memset(lock, 0, sizeof(*lock));
+	*lockp = lock;
+
+	return (0);
+}
+
+int
+pthread_rwlock_destroy(pthread_rwlock_t *lockp)
+{
+	free(*lockp);
+	*lockp = NULL;
+
+	return (0);
+}
+
+int
+pthread_rwlock_rdlock(pthread_rwlock_t *lockp)
+{
+	pthread_rwlock_t lock;
+
+	lock = *lockp;
+again:
+	_spinlock(&lock->lock);
+	if (lock->writer) {
+		_spinunlock(&lock->lock);
+		_sem_wait(&lock->sem, 0, 0);
+		goto again;
+	}
+	lock->readers++;
+	_spinunlock(&lock->lock);
+
+	return (0);
+}
+
+int
+pthread_rwlock_tryrdlock(pthread_rwlock_t *lockp)
+{
+	pthread_rwlock_t lock;
+
+	lock = *lockp;
+
+	_spinlock(&lock->lock);
+	if (lock->writer) {
+		_spinunlock(&lock->lock);
+		return (EBUSY);
+	}
+	lock->readers++;
+	_spinunlock(&lock->lock);
+
+	return (0);
+}
+
+int
+pthread_rwlock_wrlock(pthread_rwlock_t *lockp)
+{
+	pthread_rwlock_t lock;
+
+	lock = *lockp;
+
+again:
+	_spinlock(&lock->lock);
+	lock->writer++;
+	if (lock->readers) {
+		_spinunlock(&lock->lock);
+		_sem_wait(&lock->sem, 0, 0);
+		goto again;
+	}
+	lock->readers = -pthread_self()->tid;
+	_spinunlock(&lock->lock);
+
+	return (0);
+}
+
+int
+pthread_rwlock_trywrlock(pthread_rwlock_t *lockp)
+{
+	pthread_rwlock_t lock;
+
+	lock = *lockp;
+
+	_spinlock(&lock->lock);
+	if (lock->readers || lock->writer) {
+		_spinunlock(&lock->lock);
+		return (EBUSY);
+	}
+	lock->writer = 1;
+	lock->readers = -pthread_self()->tid;
+	_spinunlock(&lock->lock);
+
+	return (0);
+}
+
+int
+pthread_rwlock_unlock(pthread_rwlock_t *lockp)
+{
+	pthread_rwlock_t lock;
+
+	lock = *lockp;
+
+	_spinlock(&lock->lock);
+	if (lock->readers == -pthread_self()->tid) {
+		lock->readers = 0;
+		lock->writer--;
+	} else if (lock->readers > 0) {
+		lock->readers--;
+	} else {
+		_spinunlock(&lock->lock);
+		return (EPERM);
+	}
+	_spinunlock(&lock->lock);
+	_sem_wakeall(&lock->sem);
+
+	return (0);
+}
+
+/*
+ * rwlock attributes
+ */
+int
+pthread_rwlockattr_init(pthread_rwlockattr_t *attrp)
+{
+	pthread_rwlockattr_t attr;
+
+	attr = malloc(sizeof(*attr));
+	if (!attr)
+		return (errno);
+	memset(attr, 0, sizeof(*attr));
+	*attrp = attr;
+
+	return (0);
+}
+
+int
+pthread_rwlockattr_destory(pthread_rwlockattr_t *attrp)
+{
+	free(*attrp);
+	*attrp = NULL;
+
+	return (0);
+}
diff --git a/lib/librthread/rthread_tls.c b/lib/librthread/rthread_tls.c
new file mode 100644
index 00000000000..a1e844fe497
--- /dev/null
+++ b/lib/librthread/rthread_tls.c
@@ -0,0 +1,117 @@
+/*	$OpenBSD: rthread_tls.c,v 1.1 2005/12/03 18:16:19 tedu Exp $ */
+/*
+ * Copyright (c) 2004 Ted Unangst <tedu@openbsd.org>
+ * All Rights Reserved.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+/*
+ * thread specific storage
+ */
+
+#include <sys/param.h>
+#include <sys/mman.h>
+#include <sys/wait.h>
+
+#include <machine/spinlock.h>
+
+#include <stdlib.h>
+#include <unistd.h>
+#include <signal.h>
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+
+#include <pthread.h>
+
+#include "rthread.h"
+
+struct rthread_key *rthread_key_list;
+
+int
+pthread_key_create(pthread_key_t *key, void (*destructor)(void*))
+{
+	static int last_key;
+	struct rthread_key *rkey;
+
+	last_key++;
+
+	rkey = malloc(sizeof(*key));
+	if (!rkey)
+		return (errno);
+	rkey->keyid = last_key;
+	rkey->destructor = destructor;
+	rkey->next = rthread_key_list;
+	rthread_key_list = rkey;
+	
+	*key = last_key;
+
+	return (0);
+}
+
+int
+pthread_key_delete(pthread_key_t key)
+{
+
+	return (0);
+}
+
+static struct rthread_storage *
+rthread_findstorage(pthread_key_t key)
+{
+	struct rthread_storage *rs;
+	pthread_t self;
+
+	self = pthread_self();
+
+	for (rs = self->local_storage; rs; rs = rs->next) {
+		if (rs->keyid == key)
+			break;
+	}
+	if (!rs) {
+		rs = malloc(sizeof(*rs));
+		if (!rs)
+			return (NULL);
+		rs->keyid = key;
+		rs->data = NULL;
+		rs->next = self->local_storage;
+		self->local_storage = rs;
+	}
+
+	return (rs);
+}
+
+void *
+pthread_getspecific(pthread_key_t key)
+{
+	struct rthread_storage *rs;
+
+	rs = rthread_findstorage(key);
+	if (!rs)
+		return (NULL);
+
+	return (rs->data);
+}
+
+int
+pthread_setspecific(pthread_key_t key, const void *data)
+{
+	struct rthread_storage *rs;
+
+	rs = rthread_findstorage(key);
+	if (!rs)
+		return (ENOMEM);
+	rs->data = (void *)data;
+
+	return (0);
+}