zephyr: object: Add kboj_define support for arrays of stacks

Create a const constructor function for building the stack arrays.  This
requires unsafe, and can't use MaybeUninit, because the array version of
this is still unsable.  Just use zero initialization, and make sure the
loop initializes everything.

Use this function in the kobj_define macro in order to allow apps to
define arrays of thread stacks, in addition to arrays of threads.

Signed-off-by: David Brown <[email protected]>

Author: d3zd3z

zephyr/src/object.rs

@@ -302,6 +302,17 @@ macro_rules! _kobj_stack {
     // to write a constructor for the array as a const fn, which would greatly simplify the
     // initialization here.
     ($v:vis, $name: ident, $size:expr, $asize:expr) => {
-        compile_error!("TODO: Stack initializer array");
-    }
+        $crate::paste! {
+            // The actual stack itself goes into the no-init linker section.  We'll use the user_name,
+            // with _REAL appended, to indicate the real stack.
+            #[link_section = concat!(".noinit.", stringify!($name), ".", file!(), line!())]
+            $v static [< $name _REAL >]:
+                [$crate::sys::thread::RealStaticThreadStack<{$crate::sys::thread::stack_len($size)}>; $asize] =
+                unsafe { ::core::mem::zeroed() };
+
+            $v static $name: 
+                [$crate::_export::KStaticThreadStack; $asize] =
+                $crate::_export::KStaticThreadStack::new_from_array(&[< $name _REAL >]);
+        }
+    };
 }

zephyr/src/sys/thread.rs

@@ -38,7 +38,7 @@ extern crate alloc;
 
 #[cfg(CONFIG_RUST_ALLOC)]
 use alloc::boxed::Box;
-use core::{cell::UnsafeCell, ffi::{c_int, c_void}};
+use core::{cell::UnsafeCell, ffi::{c_int, c_void}, mem};
 
 use zephyr_sys::{
     k_thread,
@@ -137,6 +137,32 @@ impl StaticKernelObject<StaticThreadStack> {
             init: AtomicUsize::new(0),
         }
     }
+
+    /// Construct an array of StaticThreadStack kernel objects, based on the same sized array of the
+    /// RealStaticThreadStack objects.
+    ///
+    /// This is not intended to be directly called, but is used by the [`kobj_define`] macro.
+    #[doc(hidden)]
+    pub const fn new_from_array<const SZ: usize, const N: usize>(
+        real: &[RealStaticThreadStack<SZ>; N],
+    ) -> [Self; N] {
+        // Rustc currently doesn't support iterators in constant functions, but it does allow simple
+        // looping.  Since the value is not Copy, we need to use the MaybeUninit with a bit of
+        // unsafe.  This initialization is safe, as we loop through all of the entries, giving them
+        // a value.
+        //
+        // In addition, MaybeUninit::uninit_array is not stable, so do this the old unsafe way.
+        // let mut res: [MaybeUninit<Self>; N] = MaybeUninit::uninit_array();
+        // Note that `mem::uninitialized` in addition to being deprecated, isn't const.  But, since
+        // this is a const computation, zero-filling shouldn't hurt anything.
+        let mut res: [Self; N] = unsafe { mem::zeroed() };
+        let mut i = 0;
+        while i < N {
+            res[i] = Self::new_from(&real[i]);
+            i += 1;
+        }
+        res
+    }
 }
 
 /// A single Zephyr thread.