add initial pthread implementation.

git-svn-id: https://rt-thread.googlecode.com/svn/trunk@1044 bbd45198-f89e-11dd-88c7-29a3b14d5316

components/pthreads/pthread.c

+#include "pthread.h"
+
+#define PTHREAD_MAGIC	0x70746873
+struct _pthread_data
+{
+	rt_uint32_t magic;
+	pthread_attr_t attr;
+	rt_thread_t tid;
+
+	void* (*thread_entry)(void* parameter);
+	void* thread_parameter;
+
+	/* return value */
+	void* return_value;
+
+	/* semaphore for joinable thread */
+	rt_sem_t joinable_sem;
+
+	void** tls; /* thread-local storage area */
+};
+typedef struct _pthread_data _pthread_data_t;
+
+rt_inline _pthread_data_t* get_pthread_data(pthread_t thread)
+{
+	RT_ASSERT(thread != RT_NULL);
+
+	return (_pthread_data_t*)thread->user_data;
+}
+
+int pthread_system_init(void)
+{
+	return 0;
+}
+
+static void _pthread_cleanup(rt_thread_t tid)
+{
+	_pthread_data_t *ptd;
+	ptd = get_pthread_data(tid);
+
+	/* clear cleanup function */
+	tid->cleanup = RT_NULL;
+	if (ptd->attr.detachstate == PTHREAD_CREATE_JOINABLE)
+	{
+		rt_sem_release(ptd->joinable_sem);
+	}
+	else
+	{
+		/* release pthread resource */
+		pthread_detach(tid);
+	}
+}
+
+static void pthread_entry_stub(void* parameter)
+{
+	_pthread_data_t *ptd;
+	void* value;
+
+	ptd = (_pthread_data_t*)parameter;
+
+	/* execute pthread entry */
+	value = ptd->thread_entry(ptd->thread_parameter);
+	/* set value */
+	ptd->return_value = value;
+}
+
+int pthread_create (pthread_t *tid, const pthread_attr_t *attr, 
+	void *(*start) (void *), void *parameter)
+{
+	int result;
+	void* stack;
+	char name[RT_NAME_MAX];
+	static rt_uint16_t pthread_number = 0;
+	_pthread_data_t *ptd;
+
+	/* tid shall be provided */
+	RT_ASSERT(tid != RT_NULL);
+
+	/* allocate pthread data */
+	ptd = (_pthread_data_t*)rt_malloc(sizeof(_pthread_data_t));
+	if (ptd == RT_NULL) return ENOMEM;
+	/* clean memory */
+	rt_memset(ptd, 0, sizeof(_pthread_data_t));
+
+	if (attr != RT_NULL) ptd->attr = *attr;
+	else 
+	{
+		/* use default attribute */
+		pthread_attr_init(&ptd->attr);
+	}
+
+	rt_snprintf(name, sizeof(name), "pth%02d", pthread_number ++);
+	if (ptd->attr.stack_base == 0)
+	{
+		stack = (void*)rt_malloc(ptd->attr.stack_size);
+	}
+	else stack = (void*)(ptd->attr.stack_base);
+
+	if (stack == RT_NULL) 
+	{
+		rt_free(ptd);
+		return ENOMEM;
+	}
+
+	/* pthread is a static thread object */
+	ptd->tid = (rt_thread_t) rt_malloc(sizeof(struct rt_thread));
+	if (ptd->tid == RT_NULL)
+	{
+		if (ptd->attr.stack_base ==0) rt_free(stack);
+		rt_free(ptd);
+		return ENOMEM;
+	}
+
+	if (ptd->attr.detachstate == PTHREAD_CREATE_JOINABLE)
+	{
+		ptd->joinable_sem = rt_sem_create(name, 0, RT_IPC_FLAG_FIFO);
+		if (ptd->joinable_sem == RT_NULL)
+		{
+			if (ptd->attr.stack_base !=0) rt_free(stack);
+			rt_free(ptd);
+			return ENOMEM;
+		}
+	}
+	else ptd->joinable_sem = RT_NULL;
+
+	/* set parameter */
+	ptd->thread_entry = start;
+	ptd->thread_parameter = parameter;
+
+	/* initial this pthread to system */
+	if (rt_thread_init(ptd->tid, name, pthread_entry_stub, ptd, 
+		stack, ptd->attr.stack_size, 
+		ptd->attr.priority, 5) != RT_EOK)
+	{
+		if (ptd->attr.stack_base ==0) rt_free(stack);
+		if (ptd->joinable_sem != RT_NULL) rt_sem_delete(ptd->joinable_sem);
+		rt_free(ptd);
+		return EINVAL;
+	}
+
+	/* set pthread id */
+	*tid = ptd->tid;
+
+	/* set pthread cleanup function and ptd data */
+	(*tid)->cleanup = _pthread_cleanup;
+	(*tid)->user_data = (rt_uint32_t)ptd;
+
+	/* start thread */
+	result = rt_thread_startup(*tid);
+	if (result == RT_EOK) return 0;
+
+	/* start thread failed */
+	rt_thread_detach(ptd->tid);
+	if (ptd->attr.stack_base ==0) rt_free(stack);
+	if (ptd->joinable_sem != RT_NULL) rt_sem_delete(ptd->joinable_sem);
+
+	rt_free(ptd);
+	return EINVAL;
+}
+
+int pthread_detach(pthread_t thread)
+{
+	_pthread_data_t* ptd;
+
+	ptd = get_pthread_data(thread);
+
+	if (thread->stat == RT_THREAD_CLOSE)
+	{
+		/* delete joinable semaphore */
+		if (ptd->joinable_sem != RT_NULL)
+			rt_sem_delete(ptd->joinable_sem);
+		/* detach thread object */
+		rt_thread_detach(ptd->tid);
+
+		/* release thread resource */
+		if (ptd->attr.stack_base == RT_NULL)
+		{
+			/* release thread allocated stack */
+			rt_free(ptd->tid->stack_addr);
+		}
+		rt_free(ptd->tid);
+		rt_free(ptd);
+	}
+	else
+	{
+		rt_enter_critical();
+		/* change to detach state */
+		ptd->attr.detachstate = PTHREAD_CREATE_DETACHED;
+		rt_exit_critical();
+
+		/* detach joinable semaphore */
+		rt_sem_delete(ptd->joinable_sem);
+	}
+
+	return 0;
+}
+
+int pthread_join (pthread_t thread, void **value_ptr)
+{
+	_pthread_data_t* ptd;
+	rt_err_t result;
+
+	if (thread == rt_thread_self())
+	{
+		/* join self */
+		return EDEADLK;
+	}
+
+	ptd = get_pthread_data(thread);
+	if (ptd->attr.detachstate == PTHREAD_CREATE_DETACHED)
+		return EINVAL; /* join on a detached pthread */
+
+	result = rt_sem_take(ptd->joinable_sem, RT_WAITING_FOREVER);
+	if (result == RT_EOK)
+	{
+		/* get return value */
+		if (value_ptr != RT_NULL) *value_ptr = ptd->return_value;
+
+		/* release resource */
+		pthread_detach(thread);
+	}
+	else return ESRCH;
+}
+
+int pthread_cancel (pthread_t thread)
+{
+	_pthread_data_t* ptd;
+
+	ptd = get_pthread_data(thread);
+
+	/* check cancel point */
+}
+
+void pthread_exit (void* value)
+{
+	_pthread_data_t* ptd;
+
+	ptd = get_pthread_data(rt_thread_self());
+
+	/* set return value */
+	ptd->return_value = value;
+	if (ptd->attr.detachstate == PTHREAD_CREATE_JOINABLE)
+	{
+		/* release the joinable pthread */
+		rt_sem_release(ptd->joinable_sem);
+	}
+
+	/* detach thread */
+	rt_thread_detach(ptd->tid);
+	/* reschedule thread */
+	rt_schedule();
+}
+
+int pthread_once(pthread_once_t * once_control, void (*init_routine) (void))
+{
+	RT_ASSERT(once_control != RT_NULL);
+	RT_ASSERT(init_routine != RT_NULL);
+
+	rt_enter_critical();
+	if (!(*once_control))
+	{
+		/* call routine once */
+		*once_control = 1;
+		rt_exit_critical();
+
+		init_routine();
+	}
+	rt_exit_critical();
+
+	return 0;
+}
+
+int pthread_atfork(void (*prepare)(void), void (*parent)(void), void (*child)(void))
+{
+	return ENOTSUP;
+}
+

components/pthreads/pthread.h

+/*
+ * File      : pthread.h
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006 - 2010, RT-Thread Development Team
+ *
+ * The license and distribution terms for this file may be
+ * found in the file LICENSE in this distribution or at
+ * http://www.rt-thread.org/license/LICENSE
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2010-10-26     Bernard      the first version
+ */
+#ifndef __PTHREAD_H__
+#define __PTHREAD_H__
+
+#include <rtthread.h>
+#include <errno.h>
+
+#include "pthread_attr.h"
+#include "pthread_mutex.h"
+
+typedef rt_thread_t pthread_t;
+
+typedef long pthread_condattr_t;
+typedef int pthread_key_t;
+typedef int pthread_once_t;
+
+enum {
+	PTHREAD_CANCEL_ASYNCHRONOUS = 0,
+	PTHREAD_CANCEL_ENABLE,
+	PTHREAD_CANCEL_DEFERRED,
+	PTHREAD_CANCEL_DISABLE,
+	PTHREAD_CANCELED
+};
+
+#define PTHREAD_COND_INITIALIZER
+#define PTHREAD_RWLOCK_INITIALIZER
+#define PTHREAD_MUTEX_INITIALIZER	{-1, 0}
+
+#define PTHREAD_CREATE_JOINABLE		0x00
+#define PTHREAD_CREATE_DETACHED		0x01
+
+#define PTHREAD_EXPLICIT_SCHED		0
+#define PTHREAD_INHERIT_SCHED		1
+
+enum {
+    PTHREAD_MUTEX_NORMAL = 0,
+    PTHREAD_MUTEX_RECURSIVE = 1,
+    PTHREAD_MUTEX_ERRORCHECK = 2,
+    PTHREAD_MUTEX_ERRORCHECK_NP = PTHREAD_MUTEX_ERRORCHECK,
+    PTHREAD_MUTEX_RECURSIVE_NP  = PTHREAD_MUTEX_RECURSIVE,
+    PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL
+};
+
+/* init value for pthread_once_t */
+#define PTHREAD_ONCE_INIT		0
+
+enum {
+	PTHREAD_PRIO_INHERIT =0,
+	PTHREAD_PRIO_NONE,
+	PTHREAD_PRIO_PROTECT,
+};
+
+#define PTHREAD_PROCESS_PRIVATE  0
+#define PTHREAD_PROCESS_SHARED   1
+
+
+#define PTHREAD_SCOPE_PROCESS	0
+#define PTHREAD_SCOPE_SYSTEM	1
+
+struct sched_param {
+	int	sched_priority;
+};
+
+/*
+ * Scheduling policies required by IEEE Std 1003.1-2001
+ */
+#define	SCHED_OTHER	0	/* Behavior can be FIFO or RR, or not */
+#define	SCHED_FIFO	1
+#define	SCHED_RR	2
+
+int pthread_init (void);
+int pthread_create (pthread_t *tid, const pthread_attr_t *attr, 
+	void *(*start) (void *), void *arg);
+
+int pthread_detach (pthread_t thread);
+int pthread_join (pthread_t thread, void **value_ptr);
+
+rt_inline int pthread_equal (pthread_t t1, pthread_t t2)
+{
+	return t1 == t2;
+}
+
+rt_inline pthread_t pthread_self (void)
+{
+	return rt_thread_self();
+}
+
+void pthread_exit (void *value_ptr);
+
+int pthread_once(pthread_once_t * once_control, void (*init_routine) (void));
+
+/* pthread cancel */
+int pthread_cancel(pthread_t thread);
+void pthread_testcancel(void);
+
+int pthread_setcancelstate(int state, int *oldstate);
+int pthread_setcanceltype(int type, int *oldtype);
+
+int pthread_atfork(void (*prepare)(void), void (*parent)(void), void (*child)(void));
+
+#endif
+

components/pthreads/pthread_attr.c

+#include <rtthread.h>
+#include "pthread.h"
+#include <string.h>
+
+#define DEFAULT_STACK_SIZE	2048
+#define DEFAULT_PRIORITY	(RT_THREAD_PRIORITY_MAX/2 + RT_THREAD_PRIORITY_MAX/4)
+
+const pthread_attr_t pthread_default_attr = 
+{
+	0,							/* stack base */
+	DEFAULT_STACK_SIZE,			/* stack size */
+	DEFAULT_PRIORITY,			/* priority */
+	PTHREAD_CREATE_JOINABLE,	/* detach state */
+	SCHED_FIFO,					/* scheduler policy */
+	PTHREAD_INHERIT_SCHED		/* Inherit parent prio/policy */
+};
+
+int pthread_attr_init(pthread_attr_t *attr)
+{
+	RT_ASSERT(attr != RT_NULL);
+
+	*attr = pthread_default_attr;
+
+	return 0;
+}
+
+int pthread_attr_destroy(pthread_attr_t *attr)
+{
+	RT_ASSERT(attr != RT_NULL);
+
+	memset(attr, 0, sizeof(pthread_attr_t));
+	return 0;
+}
+
+int pthread_attr_setdetachstate(pthread_attr_t * attr, int state)
+{
+	RT_ASSERT(attr != RT_NULL);
+
+	if (state != PTHREAD_CREATE_JOINABLE && state != PTHREAD_CREATE_DETACHED)
+		return EINVAL;
+
+	attr->detachstate = state;
+	return 0;
+}
+
+int pthread_attr_getdetachstate(pthread_attr_t const * attr, int *state)
+{
+	RT_ASSERT(attr != RT_NULL);
+
+	*state = (int)attr->detachstate;
+
+	return 0;
+}
+
+int pthread_attr_setschedpolicy(pthread_attr_t * attr, int policy)
+{
+	RT_ASSERT(attr != RT_NULL);
+
+	attr->policy = policy;
+	return 0;
+}
+
+int pthread_attr_getschedpolicy(pthread_attr_t const *attr, int *policy)
+{
+	RT_ASSERT(attr != RT_NULL);
+
+	*policy = (int)attr->policy;
+	return 0;
+}
+
+int pthread_attr_setschedparam(pthread_attr_t *attr, struct sched_param const *param)
+{
+	RT_ASSERT(attr != RT_NULL);
+	RT_ASSERT(param != RT_NULL);
+
+	attr->priority = param->sched_priority;
+	return 0;
+}
+
+int pthread_attr_getschedparam(pthread_attr_t const *attr, struct sched_param *param)
+{
+	RT_ASSERT(attr != RT_NULL);
+	RT_ASSERT(param != RT_NULL);
+
+	param->sched_priority = attr->priority;
+	return 0;
+}
+
+int pthread_attr_setstacksize(pthread_attr_t * attr, size_t stack_size)
+{
+	RT_ASSERT(attr != RT_NULL);
+
+	attr->stack_size = stack_size;
+	return 0;
+}
+
+int pthread_attr_getstacksize(pthread_attr_t const * attr, size_t *stack_size)
+{
+	RT_ASSERT(attr != RT_NULL);
+
+	*stack_size = attr->stack_size;
+	return 0;
+}
+
+int pthread_attr_setstackaddr(pthread_attr_t * attr, void * stack_addr)
+{
+	RT_ASSERT(attr != RT_NULL);
+	return ENOTSUP;
+}
+
+int pthread_attr_getstackaddr(pthread_attr_t const * attr, void ** stack_addr)
+{
+	RT_ASSERT(attr != RT_NULL);
+	return ENOTSUP;
+}
+
+int pthread_attr_setstack(pthread_attr_t * attr, void *stack_base, size_t stack_size)
+{
+	RT_ASSERT(attr != RT_NULL);
+
+	attr->stack_base = stack_base;
+	attr->stack_size = RT_ALIGN_DOWN(stack_size, RT_ALIGN_SIZE);
+
+	return 0;
+}
+
+int pthread_attr_getstack(pthread_attr_t const * attr, void **stack_base, size_t *stack_size)
+{
+	RT_ASSERT(attr != RT_NULL);
+
+	*stack_base = attr->stack_base;
+	*stack_size = attr->stack_size;
+
+	return 0;
+}
+
+int pthread_attr_setguardsize(pthread_attr_t * attr, size_t guard_size)
+{
+	return ENOTSUP;
+}
+
+int pthread_attr_getguardsize(pthread_attr_t const * attr, size_t *guard_size)
+{
+	return ENOTSUP;
+}
+
+int pthread_attr_setscope(pthread_attr_t *attr, int scope)
+{
+    if (scope == PTHREAD_SCOPE_SYSTEM)
+        return 0;
+    if (scope == PTHREAD_SCOPE_PROCESS)
+        return ENOTSUP;
+
+    return EINVAL;
+}
+
+int pthread_attr_getscope(pthread_attr_t const *attr)
+{
+    return PTHREAD_SCOPE_SYSTEM;
+}
+

components/pthreads/pthread_attr.h

+#ifndef __PTHREAD_ATTR_H__
+#define __PTHREAD_ATTR_H__
+
+struct pthread_attr
+{
+    void* 		stack_base;
+	rt_uint16_t stack_size;		/* stack size of thread */
+
+	rt_uint8_t priority;		/* priority of thread */
+	rt_uint8_t detachstate;		/* detach state */
+	rt_uint8_t policy;			/* scheduler policy */
+	rt_uint8_t inheritsched;	/* Inherit parent prio/policy */
+};
+typedef struct pthread_attr pthread_attr_t;
+extern const pthread_attr_t pthread_default_attr;
+
+int pthread_attr_destroy(pthread_attr_t *attr);
+int pthread_attr_init(pthread_attr_t *attr);
+
+#endif

components/pthreads/pthread_cond.c

+#include "pthread_cond.h"
+
+int pthread_condattr_getpshared(const pthread_condattr_t *attr, int *pshared)
+{
+	if (!attr || !pshared) return EINVAL;
+
+	*pshared = PTHREAD_PROCESS_PRIVATE;
+	return 0;
+}
+
+int pthread_condattr_setpshared(pthread_condattr_t*attr, int pshared)
+{
+	if ((pshared != PTHREAD_PROCESS_PRIVATE) && (pshared != PTHREAD_PROCESS_SHARED))
+    	return EINVAL;
+
+	if (pshared != PTHREAD_PROCESS_PRIVATE)
+    	return ENOSYS;
+
+	return 0;
+}
+
+int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr)
+{
+	/* parameter check */
+	if (cond == RT_NULL) return EINVAL;
+	if ((attr != RT_NULL) && (*attr != PTHREAD_PROCESS_PRIVATE)) return EINVAL;
+
+	return 0;
+}
+
+int pthread_cond_destroy(pthread_cond_t *cond)
+{
+	return 0;
+}
+
+int pthread_cond_broadcast(pthread_cond_t *cond)
+{
+	return 0;
+}
+
+int pthread_cond_signal(pthread_cond_t *cond)
+{
+	return 0;
+}
+
+int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
+{
+	return 0;
+}
+
+int pthread_cond_timedwait(pthread_cond_t *cond,
+	pthread_mutex_t * mutex,
+	const struct timespec *abstime)
+{
+	return 0;
+}
+

components/pthreads/pthread_cond.h

+#ifndef __PTHREAD_COND_H__
+#define __PTHREAD_COND_H__
+
+#include <pthread.h>
+#include <sys/time.h>
+
+struct pthread_cond
+{
+	pthread_mutex_t *mutex;
+};
+typedef struct pthread_cond pthread_cond_t;
+
+int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr);
+int pthread_cond_destroy(pthread_cond_t *cond);
+int pthread_cond_broadcast(pthread_cond_t *cond);
+int pthread_cond_signal(pthread_cond_t *cond);
+
+int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
+int pthread_cond_timedwait(pthread_cond_t *cond,
+	pthread_mutex_t * mutex,
+	const struct timespec *abstime);
+
+#endif

components/pthreads/pthread_mutex.c

+#include <rtthread.h>
+#include "pthread.h"
+
+#define  MUTEXATTR_SHARED_MASK 0x0010
+#define  MUTEXATTR_TYPE_MASK   0x000f
+
+const pthread_mutexattr_t pthread_default_mutexattr = PTHREAD_PROCESS_PRIVATE;
+
+int pthread_mutexattr_init(pthread_mutexattr_t *attr)
+{
+	if (attr)
+	{
+		*attr = pthread_default_mutexattr;
+		return 0;
+	}
+
+	return EINVAL;
+}
+
+int pthread_mutexattr_destroy(pthread_mutexattr_t *attr)
+{
+	if (attr)
+	{
+	 	*attr = -1;
+		return 0;
+	}
+
+	return EINVAL;
+}
+
+int pthread_mutexattr_gettype(const pthread_mutexattr_t *attr, int *type)
+{
+	if (attr && type)
+	{
+        int  atype = (*attr & MUTEXATTR_TYPE_MASK);
+
+		if (atype >= PTHREAD_MUTEX_NORMAL && atype <= PTHREAD_MUTEX_ERRORCHECK)
+		{
+			*type = atype;
+			return 0;
+		}
+	}
+
+	return EINVAL;
+}
+
+int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int type)
+{
+    if (attr && type >= PTHREAD_MUTEX_NORMAL &&
+                type <= PTHREAD_MUTEX_ERRORCHECK )
+	{
+        *attr = (*attr & ~MUTEXATTR_TYPE_MASK) | type;
+        return 0;
+    }
+
+    return EINVAL;
+}
+
+int pthread_mutexattr_setpshared(pthread_mutexattr_t *attr, int  pshared)
+{
+    if (!attr) return EINVAL;
+
+    switch (pshared)
+	{
+    case PTHREAD_PROCESS_PRIVATE:
+        *attr &= ~MUTEXATTR_SHARED_MASK;
+        return 0;
+
+    case PTHREAD_PROCESS_SHARED:
+        *attr |= MUTEXATTR_SHARED_MASK;
+        return 0;
+    }
+
+    return EINVAL;
+}
+
+int pthread_mutexattr_getpshared(pthread_mutexattr_t *attr, int *pshared)
+{
+    if (!attr || !pshared) return EINVAL;
+
+    *pshared = (*attr & MUTEXATTR_SHARED_MASK) ? PTHREAD_PROCESS_SHARED
+                                               : PTHREAD_PROCESS_PRIVATE;
+    return 0;
+}
+
+int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr)
+{
+	rt_err_t result;
+	char name[RT_NAME_MAX];
+	static rt_uint16_t pthread_mutex_number = 0;
+
+	if (!mutex) return EINVAL;
+
+	/* build mutex name */
+	rt_snprintf(name, sizeof(name), "pmtx%02d", pthread_mutex_number ++);
+	if (attr == RT_NULL) mutex->attr = pthread_default_mutexattr;
+	else mutex->attr = *attr;
+
+	/* init mutex lock */
+	result = rt_mutex_init(&(mutex->lock), name, RT_IPC_FLAG_FIFO);
+	if (result != RT_EOK) return EINVAL;
+
+	/* detach the object from system object container */
+	rt_object_detach(&(mutex->lock.parent.parent));
+
+	return 0;
+}
+
+int pthread_mutex_destroy(pthread_mutex_t *mutex)
+{
+	if (!mutex || mutex->attr == -1) return EINVAL;
+
+	/* it's busy */
+	if (mutex->lock.owner != RT_NULL) return EBUSY;
+
+	rt_memset(mutex, 0, sizeof(pthread_mutex_t));
+	mutex->attr = -1;
+
+	return 0;
+}
+
+int pthread_mutex_lock(pthread_mutex_t *mutex)
+{
+	int mtype;
+	rt_err_t result;
+
+	if (!mutex) return EINVAL;
+
+	if (mutex->attr == -1)
+	{
+		/* init mutex */
+		pthread_mutex_init(mutex, RT_NULL);
+	}
+
+	mtype = mutex->attr & MUTEXATTR_TYPE_MASK;
+	rt_enter_critical();
+	if (mutex->lock.owner == rt_thread_self() && mtype != PTHREAD_MUTEX_RECURSIVE)
+	{
+		rt_exit_critical();
+		return EDEADLK;
+	}
+	rt_exit_critical();
+
+	result = rt_mutex_take(&(mutex->lock), RT_WAITING_FOREVER);
+	if (result == RT_EOK) return 0;
+
+	return EINVAL;
+}
+
+int pthread_mutex_unlock(pthread_mutex_t *mutex)
+{
+	rt_err_t result;
+
+	if (!mutex) return EINVAL;
+	if (mutex->attr == -1)
+	{
+		/* init mutex */
+		pthread_mutex_init(mutex, RT_NULL);
+	}
+
+	if (mutex->lock.owner != rt_thread_self())
+	{
+		int mtype;
+		mtype = mutex->attr & MUTEXATTR_TYPE_MASK;
+
+		/* error check, return EPERM */
+		if (mtype == PTHREAD_MUTEX_ERRORCHECK) return EPERM;
+
+		/* no thread waiting on this mutex */
+		if (mutex->lock.owner == RT_NULL) return 0;
+	}
+
+	result = rt_mutex_release(&(mutex->lock));
+	if (result == RT_EOK) return 0;
+}
+
+int pthread_mutex_trylock(pthread_mutex_t *mutex)
+{
+	rt_err_t result;
+
+	if (!mutex) return EINVAL;
+	if (mutex->attr == -1)
+	{
+		/* init mutex */
+		pthread_mutex_init(mutex, RT_NULL);
+	}
+
+	result = rt_mutex_take(&(mutex->lock), 0);
+	if (result == RT_EOK) return 0;
+
+	return EBUSY;
+}
+

components/pthreads/pthread_mutex.h

+#ifndef __PTHREAD_MUTEX_H__
+#define __PTHREAD_MUTEX_H__
+
+typedef long pthread_mutexattr_t;
+struct pthread_mutex
+{
+	pthread_mutexattr_t attr;
+	struct rt_mutex lock;
+};
+typedef struct pthread_mutex pthread_mutex_t;
+
+int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);
+int pthread_mutex_destroy(pthread_mutex_t *mutex);
+int pthread_mutex_lock(pthread_mutex_t *mutex);
+int pthread_mutex_unlock(pthread_mutex_t *mutex);
+int pthread_mutex_trylock(pthread_mutex_t *mutex);
+
+int pthread_mutexattr_init(pthread_mutexattr_t *attr);
+int pthread_mutexattr_destroy(pthread_mutexattr_t *attr);
+int pthread_mutexattr_gettype(const pthread_mutexattr_t *attr, int *type);
+int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int type);
+int pthread_mutexattr_setpshared(pthread_mutexattr_t *attr, int  pshared);
+int pthread_mutexattr_getpshared(pthread_mutexattr_t *attr, int *pshared);
+
+#endif

components/pthreads/pthread_rwlock.h

+#ifndef __PTHREAD_RWLOCK_H__
+#define __PTHREAD_RWLOCK_H__
+
+int pthread_rwlock_init (pthread_rwlock_t * rwlock, const pthread_rwlockattr_t * attr);
+int pthread_rwlock_destroy (pthread_rwlock_t * rwlock);
+
+int pthread_rwlock_rdlock (pthread_rwlock_t * rwlock);
+int pthread_rwlock_tryrdlock (pthread_rwlock_t * rwlock);
+int pthread_rwlock_timedrdlock (pthread_rwlock_t * rwlock, const struct timespec *abstime);
+
+int pthread_rwlock_timedwrlock (pthread_rwlock_t * rwlock, const struct timespec *abstime);
+int pthread_rwlock_trywrlock (pthread_rwlock_t * rwlock);
+int pthread_rwlock_unlock (pthread_rwlock_t * rwlock);
+int pthread_rwlock_wrlock (pthread_rwlock_t * rwlock);
+
+int pthread_rwlockattr_init (pthread_rwlockattr_t * attr);
+int pthread_rwlockattr_destroy (pthread_rwlockattr_t * attr);
+int pthread_rwlockattr_getpshared (const pthread_rwlockattr_t * attr, int *pshared);
+int pthread_rwlockattr_setpshared (pthread_rwlockattr_t * attr, int pshared);
+
+#endif

components/pthreads/pthread_spin.c

+#include "pthread_spin.h"
+
+int pthread_spin_init (pthread_spinlock_t *lock, int pshared)
+{
+	return 0;
+}
+
+int pthread_spin_destroy (pthread_spinlock_t *lock)
+{
+	return 0;
+}
+
+int pthread_spin_lock (pthread_spinlock_t * lock)
+{
+	return 0;
+}
+
+int pthread_spin_trylock (pthread_spinlock_t * lock)
+{
+	return 0;
+}
+
+int pthread_spin_unlock (pthread_spinlock_t * lock)
+{
+	return 0;
+}

components/pthreads/pthread_spin.h

+#ifndef __PTHREAD_SPIN_H__
+#define __PTHREAD_SPIN_H__
+#include <pthread.h>
+
+struct pthread_spinlock
+{
+	int pshared;
+};
+typedef struct pthread_spinlock pthread_spinlock_t;
+
+int pthread_spin_init (pthread_spinlock_t *lock, int pshared);
+int pthread_spin_destroy (pthread_spinlock_t *lock);
+
+int pthread_spin_lock (pthread_spinlock_t * lock);
+int pthread_spin_trylock (pthread_spinlock_t * lock);
+int pthread_spin_unlock (pthread_spinlock_t * lock);
+
+#endif

components/pthreads/pthread_test.c

+#include <pthread.h>
+#include <finsh.h>
+
+#define _die_(x)			do { rt_kprintf(x); RT_ASSERT(0); } while (0)
+#define pr(x)				do { rt_kprintf(x); } while (0)
+#define sleep(n)			rt_thread_sleep((n * RT_TICK_PER_SECOND)/1000)
+#define alarm(n)			
+
+/* (0) once test */
+void test0_ok() { pr("(once called) "); }
+void test0_failed() { _die_("failed...\n"); }
+void pth_t0() {
+  pthread_once_t v_once=PTHREAD_ONCE_INIT;
+  pr("\nTEST 0: once test:\n\n");
+  pr("testing once function... ");
+  pthread_once(&v_once,test0_ok);
+  pthread_once(&v_once,test0_failed);
+  pr("OK.\n");
+}
+FINSH_FUNCTION_EXPORT(pth_t0, pthread testcase0);
+
+/* (1) mutex tests */
+void test_rec_mutex() {
+  pthread_mutex_t tm;
+  pthread_mutexattr_t ta;
+  pthread_mutexattr_settype(&ta, PTHREAD_MUTEX_RECURSIVE);
+  pthread_mutex_init(&tm, &ta);
+  pr("testing recursive mutex... ");
+  alarm(5);
+  if (pthread_mutex_lock(&tm) != 0) _die_("failed... mutex_lock on unused rec-mutex (c=0)...\n");
+  if (tm.lock.owner!=pthread_self()) _die_("failed.. wrong owner....\n");
+  if (tm.lock.hold!=1) _die_("failed... wrong counting (c!=1)....\n");
+  if (pthread_mutex_lock(&tm) != 0) _die_("failed... mutex_lock on taken rec-mutex (c=1)...\n");
+  if (tm.lock.hold!=2) _die_("failed... wrong counting (c!=2)....\n");
+  if (pthread_mutex_lock(&tm) != 0) _die_("failed... mutex_lock on taken rec-mutex (c=2)...\n");
+  if (tm.lock.hold!=3) _die_("failed... wrong counting (c!=3)....\n");
+  if (pthread_mutex_unlock(&tm) != 0) _die_("failed... mutex_unlock on taken rec-mutex (c=3)...\n");
+  if (tm.lock.hold!=2) _die_("failed... wrong counting (c!=2)....\n");
+  if (tm.lock.owner==0) _die_("failed... mutex has no owner?!?!\n");
+  if (pthread_mutex_unlock(&tm) != 0) _die_("failed... mutex_unlock on taken rec-mutex (c=2)...\n");
+  if (tm.lock.hold!=1) _die_("failed... wrong counting (c!=1)....\n");
+  if (tm.lock.owner==0) _die_("failed... mutex has no owner?!?!\n");
+  if (pthread_mutex_unlock(&tm) != 0) _die_("failed... mutex_unlock on taken rec-mutex (c=1)...\n");
+  if (tm.lock.hold!=0) _die_("failed... wrong counting (c!=0)....\n");
+  if (tm.lock.owner!=0) _die_("failed... mutex still owned ?!?!\n");
+  if (pthread_mutex_unlock(&tm) != 0) _die_("failed... mutex_unlock on free rec-mutex (c=0)...\n");
+  alarm(0);
+  pr("OK.\n");
+}
+
+void test_err_mutex() {
+  pthread_mutex_t tm;
+  pthread_mutexattr_t ta;
+ 
+  pthread_mutexattr_settype(&ta, PTHREAD_MUTEX_ERRORCHECK);
+  pthread_mutex_init(&tm, &ta);
+  pr("testing errorcheck mutex... ");
+  alarm(5);
+  if (pthread_mutex_lock(&tm) != 0) _die_("failed... mutex_lock on unused errchk-mutex...\n");
+  if (tm.lock.owner!=pthread_self()) _die_("failed.. wrong owner....\n");
+  if (pthread_mutex_lock(&tm) != EDEADLK) _die_("failed... mutex_lock on taken errchk-mutex...\n");
+  if (pthread_mutex_unlock(&tm) != 0) _die_("failed... mutex_unlock on taken errchk-mutex...\n");
+  if (tm.lock.owner!=0) _die_("failed... mutex still owned ?!?!\n");
+  if (pthread_mutex_unlock(&tm) != EPERM) _die_("failed... mutex_unlock on free errchk-mutex...\n");
+  alarm(0);
+  pr("OK.\n");
+}
+
+void pth_t1() {
+  pr("\nTEST 1: mutex test:\n\n");
+  test_rec_mutex();
+  test_err_mutex();
+}
+FINSH_FUNCTION_EXPORT(pth_t1, pthread testcase0);
+
+void* thread(void*arg)
+{
+  if (0) { arg=0; }
+  pr("(thread created) ");
+  sleep(1);
+  pr("(thread exit) ");
+  return 0;
+}
+
+void test_thread() {
+  pthread_t t;
+  pr("testing basic thread creation and join... ");
+  if ((pthread_create(&t,0,thread,0))!=0) _die_("failed...\n");
+  if (pthread_join(t,0) != 0) _die_("failed... joining thread\n");
+  pr("OK.\n");
+}
+
+void test_thread_join_detached() {
+  pthread_t t;
+  pthread_attr_t attr;
+  pr("testing for failing join of a detached thread... ");
+  pthread_attr_init(&attr);
+  pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);
+  if ((pthread_create(&t,&attr,thread,0))!=0) _die_("failed...\n");
+  if (pthread_join(t,0) == 0) _die_("failed... I had joined a detached thread !\n");
+  sleep(2);
+  pr("OK.\n");
+}
+
+static char alt_stack[4096];
+void test_thread_alt_stack() {
+  pthread_t t;
+  pthread_attr_t attr;
+  pr("testing alternate thread stack... ");
+  pthread_attr_init(&attr);
+  pthread_attr_setstacksize(&attr,sizeof(alt_stack));
+  if ((pthread_create(&t,&attr,thread,0))!=0) _die_("failed... creating thread\n");
+  if (pthread_join(t,0) != 0) _die_("failed... joining thread\n");
+  pthread_attr_setstackaddr(&attr,alt_stack);
+  if ((pthread_create(&t,&attr,thread,0))!=0) _die_("failed... creating thread\n");
+  if (pthread_join(t,0) != 0) _die_("failed... joining thread\n");
+  pr("OK.\n");
+}
+
+void pth_t2()
+{
+  pr("\nTEST 2: thread creation & attributes:\n\n");
+  test_thread();
+  test_thread_join_detached();
+  test_thread_alt_stack();
+}
+FINSH_FUNCTION_EXPORT(pth_t2, pthread testcase1);

components/pthreads/sem.c

+#include <errno.h>
+#include <sys/fcntl.h>
+
+#include "sem.h"
+
+int sem_close(sem_t *sem)
+{
+}
+
+int sem_destroy(sem_t *sem)
+{
+}
+
+int sem_unlink(const char *name)
+{
+	return EACCES;
+}
+
+int sem_getvalue(sem_t *sem, int *sval)
+{
+	RT_ASSERT(sem != RT_NULL);
+	if (sval) *sval = sem->value;
+}
+
+int sem_init(sem_t *sem, int pshared, unsigned int value)
+{
+	RT_ASSERT(sem != RT_NULL);
+}
+
+sem_t *sem_open(const char *name, int oflag, ...)
+{
+	rt_sem_t sem;
+
+	sem = RT_NULL;
+	if (oflag == O_CREAT)
+	{
+		sem = rt_sem_create(name, 1, RT_IPC_FLAG_FIFO);
+		if (sem == RT_NULL)
+			rt_set_errno(ENOSPC);
+	}
+
+	if (oflag == O_EXCL)
+	{
+		rt_enter_critical();
+		/* find semaphore object */
+		rt_exit_critical();
+
+		if (sem == RT_NULL) rt_set_errno(ENOENT);
+	}
+
+	return sem;
+}
+
+int sem_post(sem_t *sem)
+{
+	rt_sem_release(sem);
+}
+
+int sem_timedwait(sem_t *sem, const struct timespec *abs_timeout)
+{
+	rt_err_t result;
+	rt_int32_t tick;
+
+	if (!sem || !abs_timeout) return EINVAL;
+
+	/* calculate os tick */
+	tick = abs_timeout->tv_sec/RT_TICK_PER_SECOND + (abs_timeout->tv_nsec/1000) * (1000/RT_TICK_PER_SECOND);
+	
+	result = rt_sem_take(sem, tick);
+	if (result == -RT_ETIMEOUT) return ETIMEDOUT;
+	if (result == RT_EOK) return 0;
+
+	return EINTR;
+}
+
+int sem_trywait(sem_t *sem)
+{
+	rt_err_t result;
+
+	if (!sem) return EINVAL;
+
+	result = rt_sem_take(sem, RT_WAITING_FOREVER);
+	if (result == -RT_ETIMEOUT) return EAGAIN;
+	if (result == RT_EOK) return 0;
+
+	return EINTR;
+}
+
+int sem_wait(sem_t *sem)
+{
+	rt_err_t result;
+
+	result = rt_sem_take(sem, RT_WAITING_FOREVER);
+	if (result == RT_EOK) return 0;
+
+	return EINTR;
+}
+

components/pthreads/sem.h

+#ifndef __POSIX_SEMAPHORE_H__
+#define __POSIX_SEMAPHORE_H__
+
+#include <rtthread.h>
+#include <sys/time.h>
+
+typedef struct rt_semaphore sem_t;
+
+int sem_close(sem_t *sem);
+int sem_destroy(sem_t *sem);
+int sem_getvalue(sem_t *sem, int *sval);
+int sem_init(sem_t *sem, int pshared, unsigned int value);
+sem_t *sem_open(const char *name, int oflag, ...);
+int sem_post(sem_t *sem);
+int sem_timedwait(sem_t *sem, const struct timespec *abs_timeout);
+int sem_trywait(sem_t *sem);
+int sem_unlink(const char *name);
+int sem_wait(sem_t *sem);
+
+#endif