Merge branch 'zephyrproject-rtos:main' into check-cfg

Author: ball-hayden

CMakeLists.txt

@@ -129,7 +129,7 @@ ${module}.path = \"$CACHE{RUST_MODULE_DIR}/${module}\"
   # symlink) in the source directory to allow various IDE tools and such to work.  The build we
   # invoke will override these settings, in case they are out of date.  Everything set here
   # should match the arguments given to the cargo build command below.
-  file(WRITE ${SAMPLE_CARGO_CONFIG} "
+  file(GENERATE OUTPUT ${SAMPLE_CARGO_CONFIG} CONTENT "
 # This is a generated sample .cargo/config.toml file from the Zephyr build.
 # At the time of generation, this represented the settings needed to allow
 # a `cargo build` command to compile the rust code using the current Zephyr build.

zephyr-sys/build.rs

@@ -77,6 +77,7 @@ fn main() -> Result<()> {
         .allowlist_function("k_.*")
         .allowlist_function("gpio_.*")
         .allowlist_function("flash_.*")
+        .allowlist_function("zr_.*")
         .allowlist_item("GPIO_.*")
         .allowlist_item("FLASH_.*")
         .allowlist_item("Z_.*")

zephyr-sys/wrapper.h

@@ -42,6 +42,7 @@ extern int errno;
 #include <zephyr/logging/log.h>
 #include <zephyr/bluetooth/bluetooth.h>
 #include <zephyr/drivers/flash.h>
+#include <zephyr/irq.h>
 
 /*
  * bindgen will only output #defined constants that resolve to simple numbers.  These are some
@@ -61,3 +62,15 @@ const uint32_t ZR_POLL_TYPE_DATA_AVAILABLE = K_POLL_TYPE_DATA_AVAILABLE;
 const uint32_t ZR_GPIO_INT_MODE_DISABLE_ONLY = GPIO_INT_MODE_DISABLE_ONLY;
 const uint32_t ZR_GPIO_INT_MODE_ENABLE_ONLY = GPIO_INT_MODE_ENABLE_ONLY;
 #endif
+
+/*
+ * Zephyr's irq_lock() and irq_unlock() are macros not inline functions, so we need some inlines to
+ * access them.
+ */
+static inline int zr_irq_lock(void) {
+	return irq_lock();
+}
+
+static inline void zr_irq_unlock(int key) {
+	irq_unlock(key);
+}

zephyr/Cargo.toml

@@ -9,6 +9,9 @@ description = """
 Functionality for Rust-based applications that run on Zephyr.
 """
 
+# 1.85 is needed to support working with or without edition 2024.
+rust-version = "1.85"
+
 [dependencies]
 zephyr-sys = { version = "0.1.0", path = "../zephyr-sys" }
 zephyr-macros = { version = "0.1.0", path = "../zephyr-macros" }

zephyr/src/sys.rs

@@ -39,42 +39,42 @@ pub fn uptime_get() -> i64 {
     unsafe { crate::raw::k_uptime_get() }
 }
 
+// The below implementation, based on interrupt locking has only been tested on single CPU.  The
+// implementation suggests it should work on SMP, and can be tested.  The docs for irq_lock()
+// explicitly state that it cannot be used from userspace. Unfortunately, spinlocks have
+// incompatible semantics with critical sections, so to work with userspace we'd need probably a
+// syscall.
+#[cfg(CONFIG_USERSPACE)]
+compile_error!("Critical-section implementation does not work with CONFIG_USERSPACE");
+
 pub mod critical {
     //! Zephyr implementation of critical sections.
     //!
-    //! Critical sections from Rust are handled with a single Zephyr spinlock.  This doesn't allow
-    //! any nesting, but neither does the `critical-section` crate.
-    //!
-    //! This provides the underlying critical section crate, which is useful for external crates
-    //! that want this interface.  However, it isn't a particularly hygienic interface to use.  For
-    //! something a bit nicer, please see [`sync::SpinMutex`].
-    //!
-    //! [`sync::SpinMutex`]: crate::sync::SpinMutex
+    //! The critical-section crate explicitly states that critical sections can be nested.
+    //! Unfortunately, Zephyr spinlocks cannot be nested.  It is possible to nest different ones,
+    //! but the critical-section implementation API doesn't give access to the stack.
 
-    use core::{ffi::c_int, ptr::addr_of_mut};
+    use core::{
+        ffi::c_int,
+        sync::atomic::{fence, Ordering},
+    };
 
     use critical_section::RawRestoreState;
-    use zephyr_sys::{k_spin_lock, k_spin_unlock, k_spinlock, k_spinlock_key_t};
+    use zephyr_sys::{zr_irq_lock, zr_irq_unlock};
 
     struct ZephyrCriticalSection;
     critical_section::set_impl!(ZephyrCriticalSection);
 
-    // The critical section shares a single spinlock.
-    static mut LOCK: k_spinlock = unsafe { core::mem::zeroed() };
-
     unsafe impl critical_section::Impl for ZephyrCriticalSection {
         unsafe fn acquire() -> RawRestoreState {
-            let res = k_spin_lock(addr_of_mut!(LOCK));
-            res.key as RawRestoreState
+            let res = zr_irq_lock();
+            fence(Ordering::Acquire);
+            res as RawRestoreState
         }
 
         unsafe fn release(token: RawRestoreState) {
-            k_spin_unlock(
-                addr_of_mut!(LOCK),
-                k_spinlock_key_t {
-                    key: token as c_int,
-                },
-            );
+            fence(Ordering::Release);
+            zr_irq_unlock(token as c_int);
         }
     }
 }

zephyr/src/thread.rs

@@ -24,7 +24,9 @@ use zephyr_sys::{
 
 use crate::{
     align::AlignAs,
+    error::to_result_void,
     sys::{K_FOREVER, K_NO_WAIT},
+    time::{Forever, Timeout},
 };
 
 /// Adjust a given requested stack size up for the alignment.  This is just the stack, and the
@@ -249,20 +251,26 @@ pub struct RunningThread {
 }
 
 impl RunningThread {
+    /// Wait, with timeout, for this thread to finish executing.
+    ///
+    /// Will block until either the thread terminates, or the timeout occurrs.
+    pub fn join_timeout<T>(&self, timeout: T) -> crate::Result<()>
+    where
+        T: Into<Timeout>,
+    {
+        let timeout: Timeout = timeout.into();
+        let ret = unsafe { k_thread_join(self.id, timeout.0) };
+        to_result_void(ret)
+    }
+
     /// Wait for this thread to finish executing.
     ///
     /// Will block until the thread has terminated.
     ///
     /// TODO: Allow a timeout?
     /// TODO: Should we try to return a value?
-    pub fn join(&self) {
-        unsafe {
-            // TODO: Can we do something meaningful with the result?
-            k_thread_join(self.id, K_FOREVER);
-
-            // TODO: Ideally, we could put the thread state back to avoid the need for another join
-            // check when re-allocating the thread.
-        }
+    pub fn join(&self) -> crate::Result<()> {
+        self.join_timeout(Forever)
     }
 }