newlib: Initial thread-safe implementation

Makefile.dep

@@ -1,6 +1,10 @@
 # pull dependencies from drivers
 include $(RIOTBASE)/drivers/Makefile.dep
 
+ifneq (,$(filter newlib_thread_safe,$(USEMODULE)))
+  USEMODULE += newlib
+endif
+
 ifneq (,$(filter libcoap,$(USEPKG)))
     USEMODULE += posix_sockets
 endif

core/include/tcb.h

@@ -81,6 +81,9 @@ typedef struct tcb_t {
     const char *name;           /**< thread's name                  */
     int stack_size;             /**< thread's stack size            */
 #endif
+#ifdef MODULE_NEWLIB_THREAD_SAFE
+    struct reent newlib_reent; /**< thread's re-entrent object     */
+#endif
 } tcb_t;
 
 #ifdef __cplusplus

core/sched.c

@@ -117,6 +117,10 @@ int sched_run(void)
     sched_active_pid = next_thread->pid;
     sched_active_thread = (volatile tcb_t *) next_thread;
 
+#ifdef MODULE_NEWLIB_THREAD_SAFE
+    _impure_ptr = &(sched_active_thread->newlib_reent);
+#endif
+
     DEBUG("sched_run: done, changed sched_active_thread.\n");
 
     return 1;

sys/newlib/thread_safe/Makefile

@@ -0,0 +1,3 @@
+MODULE = newlib_thread_safe
+
+include $(RIOTBASE)/Makefile.base

sys/newlib/thread_safe/env_lock.c

@@ -0,0 +1,74 @@
+/*
+ * Copyright (C) 2015 Engineering-Spirit
+ *
+ * This file is subject to the terms and conditions of the GNU Lesser General
+ * Public License v2.1. See the file LICENSE in the top level directory for more
+ * details.
+ */
+
+/**
+ * @ingroup     sys_newlib
+ * @{
+ *
+ * @file
+ * @brief       Newlib thread-safe env implementation
+ *
+ * @author      Nick v. IJzendoorn <nijzendoorn@engineering-spirit.nl>
+ *
+ * @}
+ */
+
+#include <sys/reent.h>
+
+#include <thread.h>
+#include <mutex.h>
+
+#if MODULE_NEWLIB_THREAD_SAFE
+static volatile kernel_pid_t _env_owner = KERNEL_PID_UNDEF;
+static atomic_int_t _env_lock_recursion;
+static mutex_t _env_mutex;
+#endif
+
+/**
+ * @brief   __env_lock needs to provide recursive mutex locking
+ */
+void __env_lock(struct _reent *_r)
+{
+    /* TODO another way would be to avoid rescheduling other tasks */
+#if MODULE_NEWLIB_THREAD_SAFE
+    switch (mutex_trylock(&_env_mutex))
+    {
+    case 0:
+        /* mutex is already locked */
+        if (_env_owner != thread_getpid()) {
+            /* we are not the owner, so we wait till it's released  and
+             * fall-trough the case statement */
+            mutex_lock(&_env_mutex);
+        }
+
+        continue;
+
+    case 1:
+        /* mutex now locked by us */
+        atomic_inc(&_env_lock_recursion);
+        _env_owner = thread_getpid();
+        break;
+    }
+#else
+    (void) _r;
+#endif
+}
+
+void __env_unlock(struct _reent *_r)
+{
+#if MODULE_NEWLIB_THREAD_SAFE
+    if (atomic_dec(&_env_lock_recursion) == 1) {
+        /* we just released the last recursion lock call */
+
+        _env_owner = KERNEL_PID_UNDEF;
+        mutex_unlock(&_env_mutex);
+    }
+#else
+    (void) _r;
+#endif
+}

sys/newlib/thread_safe/malloc_lock.c

@@ -0,0 +1,74 @@
+/*
+ * Copyright (C) 2015 Engineering-Spirit
+ *
+ * This file is subject to the terms and conditions of the GNU Lesser General
+ * Public License v2.1. See the file LICENSE in the top level directory for more
+ * details.
+ */
+
+/**
+ * @ingroup     sys_newlib
+ * @{
+ *
+ * @file
+ * @brief       Newlib thread-safe malloc implementation
+ *
+ * @author      Nick v. IJzendoorn <nijzendoorn@engineering-spirit.nl>
+ *
+ * @}
+ */
+
+#include <sys/reent.h>
+
+#include <thread.h>
+#include <mutex.h>
+
+#if MODULE_NEWLIB_THREAD_SAFE
+static volatile kernel_pid_t _malloc_owner = KERNEL_PID_UNDEF;
+static atomic_int_t _malloc_lock_recursion;
+static mutex_t _malloc_mutex;
+#endif
+
+/**
+ * @brief   __malloc_lock needs to provide recursive mutex locking
+ */
+void __malloc_lock(struct _reent *_r)
+{
+    /* TODO another way would be to avoid rescheduling other tasks */
+#if MODULE_NEWLIB_THREAD_SAFE
+    switch (mutex_trylock(&_malloc_mutex))
+    {
+    case 0:
+        /* mutex is already locked */
+        if (_malloc_owner != thread_getpid()) {
+            /* we are not the owner, so we wait till it's released  and
+             * fall-trough the case statement */
+            mutex_lock(&_malloc_mutex);
+        }
+
+        continue;
+
+    case 1:
+        /* mutex now locked by us */
+        atomic_inc(&_malloc_lock_recursion);
+        _malloc_owner = thread_getpid();
+        break;
+    }
+#else
+    (void) _r;
+#endif
+}
+
+void __malloc_unlock(struct _reent *_r)
+{
+#if MODULE_NEWLIB_THREAD_SAFE
+    if (atomic_dec(&_malloc_lock_recursion) == 1) {
+        /* we just released the last recursion lock call */
+
+        _malloc_owner = KERNEL_PID_UNDEF;
+        mutex_unlock(&_malloc_mutex);
+    }
+#else
+    (void) _r;
+#endif
+}