Merge pull request #2680 from BernardXiong/pthreads

[pthreads] Change the pthreads management.

components/libc/Kconfig

@@ -8,6 +8,12 @@ config RT_USING_PTHREADS
     bool "Enable pthreads APIs"
     default n
 
+if RT_USING_PTHREADS
+    config PTHREAD_NUM_MAX
+    int "Maximum number of pthreads"
+    default 8
+endif
+
 if RT_USING_LIBC && RT_USING_DFS
     config RT_USING_POSIX
         bool "Enable POSIX layer for poll/select, stdin etc"

components/libc/pthreads/pthread.c

@@ -10,10 +10,121 @@
  * 2019-02-07     Bernard      Add _pthread_destroy to release pthread resource.
  */
 
+#include <rthw.h>
 #include <pthread.h>
 #include <sched.h>
 #include "pthread_internal.h"
 
+RT_DEFINE_SPINLOCK(pth_lock);
+_pthread_data_t *pth_table[PTHREAD_NUM_MAX] = {NULL};
+
+_pthread_data_t *_pthread_get_data(pthread_t thread)
+{
+    RT_DECLARE_SPINLOCK(pth_lock);
+    _pthread_data_t *ptd;
+
+    if (thread >= PTHREAD_NUM_MAX) return NULL;
+
+    rt_hw_spin_lock(&pth_lock);
+    ptd = pth_table[thread];
+    rt_hw_spin_unlock(&pth_lock);
+
+    if (ptd && ptd->magic == PTHREAD_MAGIC) return ptd;
+
+    return NULL;
+}
+
+pthread_t _pthread_data_get_pth(_pthread_data_t *ptd)
+{
+    int index;
+    RT_DECLARE_SPINLOCK(pth_lock);
+
+    rt_hw_spin_lock(&pth_lock);
+    for (index = 0; index < PTHREAD_NUM_MAX; index ++)
+    {
+        if (pth_table[index] == ptd) break;
+    }
+    rt_hw_spin_unlock(&pth_lock);
+
+    return index;
+}
+
+pthread_t _pthread_data_create(void)
+{
+    int index;
+    _pthread_data_t *ptd = NULL;
+    RT_DECLARE_SPINLOCK(pth_lock);
+
+    ptd = (_pthread_data_t*)rt_malloc(sizeof(_pthread_data_t));
+    if (!ptd) return PTHREAD_NUM_MAX;
+
+    memset(ptd, 0x0, sizeof(_pthread_data_t));
+    ptd->canceled = 0;
+    ptd->cancelstate = PTHREAD_CANCEL_DISABLE;
+    ptd->canceltype = PTHREAD_CANCEL_DEFERRED;
+    ptd->magic = PTHREAD_MAGIC;
+
+    rt_hw_spin_lock(&pth_lock);
+    for (index = 0; index < PTHREAD_NUM_MAX; index ++)
+    {
+        if (pth_table[index] == NULL)
+        {
+            pth_table[index] = ptd;
+            break;
+        }
+    }
+    rt_hw_spin_unlock(&pth_lock);
+
+    /* full of pthreads, clean magic and release ptd */
+    if (index == PTHREAD_NUM_MAX)
+    {
+        ptd->magic = 0x0;
+        rt_free(ptd);
+    }
+
+    return index;
+}
+
+void _pthread_data_destroy(pthread_t pth)
+{
+    RT_DECLARE_SPINLOCK(pth_lock);
+
+    _pthread_data_t *ptd = _pthread_get_data(pth);
+    if (ptd)
+    {
+        /* remove from pthread table */
+        rt_hw_spin_lock(&pth_lock);
+        pth_table[pth] = NULL;
+        rt_hw_spin_unlock(&pth_lock);
+
+        /* delete joinable semaphore */
+        if (ptd->joinable_sem != RT_NULL)
+            rt_sem_delete(ptd->joinable_sem);
+
+        /* release thread resource */
+        if (ptd->attr.stackaddr == RT_NULL)
+        {
+            /* release thread allocated stack */
+            rt_free(ptd->tid->stack_addr);
+        }
+        /* clean stack addr pointer */
+        ptd->tid->stack_addr = RT_NULL;
+
+        /*
+        * if this thread create the local thread data,
+        * delete it
+        */
+        if (ptd->tls != RT_NULL) rt_free(ptd->tls);
+        rt_free(ptd->tid);
+
+        /* clean magic */
+        ptd->magic = 0x0;
+
+        /* free ptd */
+        rt_free(ptd);
+    }
+}
+
 int pthread_system_init(void)
 {
     /* initialize key area */
@@ -29,26 +140,11 @@ INIT_COMPONENT_EXPORT(pthread_system_init);
 
 static void _pthread_destroy(_pthread_data_t *ptd)
 {
-    /* delete joinable semaphore */
+    pthread_t pth = _pthread_data_get_pth(ptd);
-    if (ptd->joinable_sem != RT_NULL)
+    if (pth != PTHREAD_NUM_MAX)
-        rt_sem_delete(ptd->joinable_sem);
-
-    /* release thread resource */
-    if (ptd->attr.stackaddr == RT_NULL)
     {
-        /* release thread allocated stack */
+        _pthread_data_destroy(pth);
-        rt_free(ptd->tid->stack_addr);
     }
-    /* clean stack addr pointer */
-    ptd->tid->stack_addr = RT_NULL;
-
-    /*
-    * if this thread create the local thread data,
-    * delete it
-    */
-    if (ptd->tls != RT_NULL) rt_free(ptd->tls);
-    rt_free(ptd->tid);
-    rt_free(ptd);
 
     return;
 }
@@ -56,7 +152,10 @@ static void _pthread_destroy(_pthread_data_t *ptd)
 static void _pthread_cleanup(rt_thread_t tid)
 {
     _pthread_data_t *ptd;
-    ptd = _pthread_get_data(tid);
+
+    /* get pthread data from user data of thread */
+    ptd = (_pthread_data_t *)tid->user_data;
+    RT_ASSERT(ptd != RT_NULL);
 
     /* clear cleanup function */
     tid->cleanup = RT_NULL;
@@ -84,29 +183,30 @@ static void pthread_entry_stub(void *parameter)
     ptd->return_value = value;
 }
 
-int pthread_create(pthread_t            *tid,
+int pthread_create(pthread_t            *pid,
                    const pthread_attr_t *attr,
                    void *(*start)(void *), void *parameter)
 {
-    int result;
+    int ret = 0;
     void *stack;
     char name[RT_NAME_MAX];
     static rt_uint16_t pthread_number = 0;
+
+    pthread_t pth_id;
     _pthread_data_t *ptd;
 
-    /* tid shall be provided */
+    /* pid shall be provided */
-    RT_ASSERT(tid != RT_NULL);
+    RT_ASSERT(pid != RT_NULL);
 
     /* allocate posix thread data */
-    ptd = (_pthread_data_t *)rt_malloc(sizeof(_pthread_data_t));
+    pth_id = _pthread_data_create();
-    if (ptd == RT_NULL)
+    if (pth_id == PTHREAD_NUM_MAX) 
-        return ENOMEM;
+    {
-    /* clean posix thread data memory */
+        ret = ENOMEM;
-    rt_memset(ptd, 0, sizeof(_pthread_data_t));
+        goto __exit;
-    ptd->canceled = 0;
+    }
-    ptd->cancelstate = PTHREAD_CANCEL_DISABLE;
+    /* get pthread data */
-    ptd->canceltype = PTHREAD_CANCEL_DEFERRED;
+    ptd = _pthread_get_data(pth_id);
-    ptd->magic = PTHREAD_MAGIC;
 
     if (attr != RT_NULL)
     {
@@ -130,20 +230,16 @@ int pthread_create(pthread_t            *tid,
 
     if (stack == RT_NULL)
     {
-        rt_free(ptd);
+        ret = ENOMEM;
-
+        goto __exit;
-        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.stackaddr == 0)
+        ret = ENOMEM;
-            rt_free(stack);
+        goto __exit;
-        rt_free(ptd);
-
-        return ENOMEM;
     }
 
     if (ptd->attr.detachstate == PTHREAD_CREATE_JOINABLE)
@@ -151,11 +247,8 @@ int pthread_create(pthread_t            *tid,
         ptd->joinable_sem = rt_sem_create(name, 0, RT_IPC_FLAG_FIFO);
         if (ptd->joinable_sem == RT_NULL)
         {
-            if (ptd->attr.stackaddr != 0)
+            ret = ENOMEM;
-                rt_free(stack);
+            goto __exit;
-            rt_free(ptd);
-
-            return ENOMEM;
         }
     }
     else
@@ -172,37 +265,29 @@ int pthread_create(pthread_t            *tid,
                        stack, ptd->attr.stacksize,
                        ptd->attr.schedparam.sched_priority, 5) != RT_EOK)
     {
-        if (ptd->attr.stackaddr == 0)
+        ret = EINVAL;
-            rt_free(stack);
+        goto __exit;
-        if (ptd->joinable_sem != RT_NULL)
-            rt_sem_delete(ptd->joinable_sem);
-        rt_free(ptd);
-
-        return EINVAL;
     }
 
     /* set pthread id */
-    *tid = ptd->tid;
+    *pid = pth_id;
 
     /* set pthread cleanup function and ptd data */
-    (*tid)->cleanup = _pthread_cleanup;
+    ptd->tid->cleanup = _pthread_cleanup;
-    (*tid)->user_data = (rt_uint32_t)ptd;
+    ptd->tid->user_data = (rt_uint32_t)ptd;
 
     /* start thread */
-    result = rt_thread_startup(*tid);
+    if (rt_thread_startup(ptd->tid) == RT_EOK)
-    if (result == RT_EOK)
         return 0;
 
     /* start thread failed */
     rt_thread_detach(ptd->tid);
-    if (ptd->attr.stackaddr == 0)
+    ret = EINVAL;
-        rt_free(stack);
-    if (ptd->joinable_sem != RT_NULL)
-        rt_sem_delete(ptd->joinable_sem);
 
-    rt_free(ptd);
+__exit:
-
+    if (pth_id != PTHREAD_NUM_MAX)
-    return EINVAL;
+        _pthread_data_destroy(pth_id);
+    return ret;
 }
 RTM_EXPORT(pthread_create);
 
@@ -221,7 +306,7 @@ int pthread_detach(pthread_t thread)
         goto __exit;
     }
 
-    if ((thread->stat & RT_THREAD_STAT_MASK) == RT_THREAD_CLOSE)
+    if ((ptd->tid->stat & RT_THREAD_STAT_MASK) == RT_THREAD_CLOSE)
     {
         /* this defunct pthread is not handled by idle */
         if (rt_sem_trytake(ptd->joinable_sem) != RT_EOK)
@@ -270,13 +355,13 @@ int pthread_join(pthread_t thread, void **value_ptr)
     _pthread_data_t *ptd;
     rt_err_t result;
 
-    if (thread == rt_thread_self())
+    ptd = _pthread_get_data(thread);
+    if (ptd && ptd->tid == rt_thread_self())
     {
         /* join self */
         return EDEADLK;
     }
 
-    ptd = _pthread_get_data(thread);
     if (ptd->attr.detachstate == PTHREAD_CREATE_DETACHED)
         return EINVAL; /* join on a detached pthread */
 
@@ -299,13 +384,32 @@ int pthread_join(pthread_t thread, void **value_ptr)
 }
 RTM_EXPORT(pthread_join);
 
+pthread_t pthread_self (void)
+{
+    rt_thread_t tid;
+    _pthread_data_t *ptd;
+
+    tid = rt_thread_self();
+    if (tid == NULL) return PTHREAD_NUM_MAX;
+
+    /* get pthread data from user data of thread */
+    ptd = (_pthread_data_t *)rt_thread_self()->user_data;
+    RT_ASSERT(ptd != RT_NULL);
+
+    return _pthread_data_get_pth(ptd);
+}
+RTM_EXPORT(pthread_self);
+
 void pthread_exit(void *value)
 {
     _pthread_data_t *ptd;
     _pthread_cleanup_t *cleanup;
     extern _pthread_key_data_t _thread_keys[PTHREAD_KEY_MAX];
 
-    ptd = _pthread_get_data(rt_thread_self());
+    if (rt_thread_self() == NULL) return;
+
+    /* get pthread data from user data of thread */
+    ptd = (_pthread_data_t *)rt_thread_self()->user_data;
 
     rt_enter_critical();
     /* disable cancel */
@@ -382,7 +486,15 @@ RTM_EXPORT(pthread_atfork);
 int pthread_kill(pthread_t thread, int sig)
 {
 #ifdef RT_USING_SIGNALS
-    return rt_thread_kill(thread, sig);
+    _pthread_data_t *ptd;
+
+    ptd = _pthread_get_data(thread);
+    if (ptd)
+    {
+        return rt_thread_kill(ptd->tid, sig);
+    }
+
+    return EINVAL;
 #else
     return ENOSYS;
 #endif
@@ -401,8 +513,10 @@ void pthread_cleanup_pop(int execute)
     _pthread_data_t *ptd;
     _pthread_cleanup_t *cleanup;
 
-    /* get posix thread data */
+    if (rt_thread_self() == NULL) return;
-    ptd = _pthread_get_data(rt_thread_self());
+
+    /* get pthread data from user data of thread */
+    ptd = (_pthread_data_t *)rt_thread_self()->user_data;
     RT_ASSERT(ptd != RT_NULL);
 
     if (execute)
@@ -428,8 +542,10 @@ void pthread_cleanup_push(void (*routine)(void *), void *arg)
     _pthread_data_t *ptd;
     _pthread_cleanup_t *cleanup;
 
-    /* get posix thread data */
+    if (rt_thread_self() == NULL) return;
-    ptd = _pthread_get_data(rt_thread_self());
+
+    /* get pthread data from user data of thread */
+    ptd = (_pthread_data_t *)rt_thread_self()->user_data;
     RT_ASSERT(ptd != RT_NULL);
 
     cleanup = (_pthread_cleanup_t *)rt_malloc(sizeof(_pthread_cleanup_t));
@@ -478,8 +594,10 @@ int pthread_setcancelstate(int state, int *oldstate)
 {
     _pthread_data_t *ptd;
 
-    /* get posix thread data */
+    if (rt_thread_self() == NULL) return EINVAL;
-    ptd = _pthread_get_data(rt_thread_self());
+
+    /* get pthread data from user data of thread */
+    ptd = (_pthread_data_t *)rt_thread_self()->user_data;
     RT_ASSERT(ptd != RT_NULL);
 
     if ((state == PTHREAD_CANCEL_ENABLE) || (state == PTHREAD_CANCEL_DISABLE))
@@ -499,8 +617,10 @@ int pthread_setcanceltype(int type, int *oldtype)
 {
     _pthread_data_t *ptd;
 
-    /* get posix thread data */
+    if (rt_thread_self() == NULL) return EINVAL;
-    ptd = _pthread_get_data(rt_thread_self());
+
+    /* get pthread data from user data of thread */
+    ptd = (_pthread_data_t *)rt_thread_self()->user_data;
     RT_ASSERT(ptd != RT_NULL);
 
     if ((type != PTHREAD_CANCEL_DEFERRED) && (type != PTHREAD_CANCEL_ASYNCHRONOUS))
@@ -519,8 +639,10 @@ void pthread_testcancel(void)
     int cancel = 0;
     _pthread_data_t *ptd;
 
-    /* get posix thread data */
+    if (rt_thread_self() == NULL) return;
-    ptd = _pthread_get_data(rt_thread_self());
+
+    /* get pthread data from user data of thread */
+    ptd = (_pthread_data_t *)rt_thread_self()->user_data;
     RT_ASSERT(ptd != RT_NULL);
 
     if (ptd->cancelstate == PTHREAD_CANCEL_ENABLE)
@@ -534,14 +656,14 @@ int pthread_cancel(pthread_t thread)
 {
     _pthread_data_t *ptd;
 
-    /* cancel self */
-    if (thread == rt_thread_self())
-        return 0;
-
     /* get posix thread data */
     ptd = _pthread_get_data(thread);
     RT_ASSERT(ptd != RT_NULL);
 
+    /* cancel self */
+    if (ptd->tid == rt_thread_self())
+        return 0;
+
     /* set canceled */
     if (ptd->cancelstate == PTHREAD_CANCEL_ENABLE)
     {
@@ -555,10 +677,11 @@ int pthread_cancel(pthread_t thread)
              * thread (pthread_cleanup), it will move to defunct
              * thread list and wait for handling in idle thread.
              */
-            rt_thread_detach(thread);
+            rt_thread_detach(ptd->tid);
         }
     }
 
     return 0;
 }
 RTM_EXPORT(pthread_cancel);
+

components/libc/pthreads/pthread.h

@@ -32,7 +32,7 @@ extern "C" {
 #define PTHREAD_EXPLICIT_SCHED      0
 #define PTHREAD_INHERIT_SCHED       1
 
-typedef rt_thread_t pthread_t;
+typedef long pthread_t;
 typedef long pthread_condattr_t;
 typedef long pthread_rwlockattr_t;
 typedef long pthread_mutexattr_t;
@@ -172,10 +172,7 @@ rt_inline int pthread_equal (pthread_t t1, pthread_t t2)
     return t1 == t2;
 }
 
-rt_inline pthread_t pthread_self (void)
+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));

components/libc/pthreads/pthread_cond.c

@@ -189,7 +189,7 @@ rt_err_t _pthread_cond_timedwait(pthread_cond_t  *cond,
         pthread_cond_init(cond, RT_NULL);
 
     /* The mutex was not owned by the current thread at the time of the call. */
-    if (mutex->lock.owner != pthread_self())
+    if (mutex->lock.owner != rt_thread_self())
         return -RT_ERROR;
     /* unlock a mutex failed */
     if (pthread_mutex_unlock(mutex) != 0)

components/libc/pthreads/pthread_internal.h

@@ -30,6 +30,10 @@ struct _pthread_key_data
 };
 typedef struct _pthread_key_data _pthread_key_data_t;
 
+#ifndef PTHREAD_NUM_MAX
+#define PTHREAD_NUM_MAX 32
+#endif
+
 #define PTHREAD_MAGIC   0x70746873
 struct _pthread_data
 {
@@ -56,17 +60,7 @@ struct _pthread_data
 };
 typedef struct _pthread_data _pthread_data_t;
 
-rt_inline _pthread_data_t *_pthread_get_data(pthread_t thread)
+_pthread_data_t *_pthread_get_data(pthread_t thread);
-{
-    _pthread_data_t *ptd;
-    RT_ASSERT(thread != RT_NULL);
-
-    ptd = (_pthread_data_t *)thread->user_data;
-    RT_ASSERT(ptd != RT_NULL);
-    RT_ASSERT(ptd->magic == PTHREAD_MAGIC);
-
-    return ptd;
-}
 
 int clock_time_to_tick(const struct timespec *time);
 

components/libc/pthreads/pthread_tls.c

@@ -22,7 +22,10 @@ void *pthread_getspecific(pthread_key_t key)
 {
     struct _pthread_data* ptd;
 
-    ptd = _pthread_get_data(rt_thread_self());
+    if (rt_thread_self() == NULL) return NULL;
+
+    /* get pthread data from user data of thread */
+    ptd = (_pthread_data_t *)rt_thread_self()->user_data;
     RT_ASSERT(ptd != NULL);
 
     if (ptd->tls == NULL)
@@ -39,7 +42,10 @@ int pthread_setspecific(pthread_key_t key, const void *value)
 {
     struct _pthread_data* ptd;
 
-    ptd = _pthread_get_data(rt_thread_self());
+    if (rt_thread_self() == NULL) return EINVAL;
+
+    /* get pthread data from user data of thread */
+    ptd = (_pthread_data_t *)rt_thread_self()->user_data;
     RT_ASSERT(ptd != NULL);
 
     /* check tls area */

include/rthw.h

@@ -157,6 +157,7 @@ extern rt_hw_spinlock_t _rt_critical_lock;
     (rt_hw_spinlock_t) __RT_HW_SPIN_LOCK_INITIALIZER(lockname)
 
 #define RT_DEFINE_SPINLOCK(x)  rt_hw_spinlock_t x = __RT_HW_SPIN_LOCK_UNLOCKED(x)
+#define RT_DECLARE_SPINLOCK(x)
 
 /**
  *  ipi function
@@ -172,6 +173,13 @@ void rt_hw_secondary_cpu_up(void);
  * secondary cpu idle function
  */
 void rt_hw_secondary_cpu_idle_exec(void);
+#else
+
+#define RT_DEFINE_SPINLOCK(x)  
+#define RT_DECLARE_SPINLOCK(x)    rt_ubase_t x
+
+#define rt_hw_spin_lock(lock)     *(lock) = rt_hw_interrupt_disable()
+#define rt_hw_spin_unlock(lock)   rt_hw_interrupt_enable(*(lock))
 
 #endif