Implement thread-local storage without pthread.

Author: reitermarkus

src/libstd/lib.rs

@@ -280,6 +280,7 @@
 #![feature(libc)]
 #![feature(link_args)]
 #![feature(linkage)]
+#![feature(linked_list_remove)]
 #![feature(llvm_asm)]
 #![feature(log_syntax)]
 #![feature(maybe_uninit_ref)]

src/libstd/sys/unix/freertos/ffi.rs

@@ -7,6 +7,7 @@ pub type TaskHandle_t = *mut libc::c_void;
 pub type QueueHandle_t = *mut libc::c_void;
 pub type SemaphoreHandle_t = QueueHandle_t;
 pub type TaskFunction_t = extern "C" fn(*mut libc::c_void) -> *mut libc::c_void;
+pub type TlsDeleteCallbackFunction_t = unsafe extern "C" fn(libc::c_int, *mut libc::c_void);
 
 pub const queueQUEUE_TYPE_MUTEX: u8 = 1;
 pub const queueQUEUE_TYPE_RECURSIVE_MUTEX: u8 = 4;
@@ -63,6 +64,9 @@ extern "C" {
         pxCreatedTask: *mut TaskHandle_t,
         xCoreID: BaseType_t,
     ) -> BaseType_t;
+    pub fn pvTaskGetThreadLocalStoragePointer(xTaskToQuery: TaskHandle_t, xIndex: BaseType_t) -> *mut libc::c_void;
+    pub fn vTaskSetThreadLocalStoragePointer(xTaskToQuery: TaskHandle_t, xIndex: BaseType_t, pvValue: *mut libc::c_void);
+    pub fn vTaskSetThreadLocalStoragePointerAndDelCallback(xTaskToQuery: TaskHandle_t, xIndex: BaseType_t, pvValue: *mut libc::c_void, xDelCallback: TlsDeleteCallbackFunction_t);
 }
 
 #[cfg(target_device = "esp32")]

src/libstd/sys/unix/freertos/thread.rs

@@ -9,6 +9,7 @@ use crate::sys_common::thread::*;
 use crate::pin::Pin;
 
 use crate::sys::ffi::*;
+use crate::sys::thread_local;
 
 const RUNNING: usize = 0;
 const DETACHED: usize = 1;
@@ -66,6 +67,7 @@ impl Thread {
                 join_mutex.lock();
 
                 main();
+                thread_local::cleanup();
 
                 let previous_state = state.swap(EXITED, SeqCst);
 

src/libstd/sys/unix/freertos/thread_local.rs

@@ -1,31 +1,125 @@
-#![allow(dead_code)] // not used on all platforms
+use crate::collections::{LinkedList, BTreeMap};
+use crate::ptr;
+use crate::sys::ffi::*;
+use crate::sys_common::rwlock::RWLock;
 
-use crate::mem;
+pub type Key = usize;
+type Tls = BTreeMap<Key, *mut u8>;
 
-pub type Key = libc::pthread_key_t;
+const TLS_INDEX: BaseType_t = 1;
+
+static LOCK: RWLock = RWLock::new();
+static mut KEYS: LinkedList<(Key, Option<unsafe extern "C" fn(*mut u8)>)> = LinkedList::new();
+
+#[inline]
+unsafe fn get_tls() -> *mut Tls {
+    pvTaskGetThreadLocalStoragePointer(ptr::null_mut(), TLS_INDEX) as *mut Tls
+}
 
 #[inline]
-pub unsafe fn create(dtor: Option<unsafe extern fn(*mut u8)>) -> Key {
-    let mut key = 0;
-    assert_eq!(libc::pthread_key_create(&mut key, mem::transmute(dtor)), 0);
+unsafe fn set_tls(tls: *mut Tls) {
+    vTaskSetThreadLocalStoragePointer(ptr::null_mut(), TLS_INDEX, tls as *mut _);
+}
+
+#[inline]
+pub unsafe fn cleanup() {
+    if let Some(mut tls) = get_tls().as_mut() {
+        let tls = Box::from_raw(tls);
+
+        LOCK.read();
+
+        for (k, dtor) in KEYS.iter() {
+            if let (Some(v), Some(dtor)) = (tls.get(k), dtor) {
+                dtor(*v)
+            }
+        }
+
+        LOCK.read_unlock();
+
+        set_tls(ptr::null_mut());
+    }
+}
+
+#[inline]
+pub unsafe fn create(dtor: Option<unsafe extern "C" fn(*mut u8)>) -> Key {
+    LOCK.write();
+
+    let key = KEYS.back().map(|&(i, _)| i + 1).unwrap_or(1);
+    KEYS.push_back((key, dtor));
+
+    LOCK.write_unlock();
+
     key
 }
 
 #[inline]
 pub unsafe fn set(key: Key, value: *mut u8) {
-    let r = libc::pthread_setspecific(key, value as *mut _);
-    debug_assert_eq!(r, 0);
+    #[cfg(debug)]
+    {
+        LOCK.read();
+
+        let mut found = false;
+
+        for (k, _) in KEYS.iter() {
+            if k == key {
+                found = true;
+                break;
+            }
+        }
+
+        assert!(found);
+
+        LOCK.read_unlock();
+    }
+
+
+    let mut tls = if let Some(mut tls) = get_tls().as_mut() {
+        tls
+    } else {
+        let mut tls = Box::into_raw(box Tls::new());
+        set_tls(tls);
+        &mut *tls
+    };
+
+    if value.is_null() {
+        tls.remove(&key);
+    } else {
+        tls.insert(key, value);
+    }
 }
 
 #[inline]
 pub unsafe fn get(key: Key) -> *mut u8 {
-    libc::pthread_getspecific(key) as *mut u8
+    if let Some(tls) = get_tls().as_mut() {
+        tls.get(&key).cloned().unwrap_or_else(ptr::null_mut)
+    } else {
+        ptr::null_mut()
+    }
 }
 
 #[inline]
 pub unsafe fn destroy(key: Key) {
-    let r = libc::pthread_key_delete(key);
-    debug_assert_eq!(r, 0);
+    LOCK.write();
+
+    let mut i = 0;
+    let mut found = false;
+
+    for &(k, _) in KEYS.iter() {
+        if k == key {
+            found = true;
+            break;
+        }
+
+        i += 1;
+    }
+
+    debug_assert!(found);
+
+    if found {
+        KEYS.remove(i);
+    }
+
+    LOCK.write_unlock();
 }
 
 #[inline]