zephry: object: Create Fixed concept

The `Fixed` type encapsulates something that can either be a statically
allocated object or a dynamically allocated one.  It is conditional on
`CONFIG_RUST_ALLOC`, and if that is not defined, will just end up
represented as the underlying static pointer.

Author: d3zd3z

zephyr/src/object.rs

@@ -79,8 +79,17 @@
 //! [`kobj_define!`]: crate::kobj_define
 //! [`init_once`]: StaticKernelObject::init_once
 
+#[cfg(CONFIG_RUST_ALLOC)]
+extern crate alloc;
+
 use core::{cell::UnsafeCell, mem};
 
+#[cfg(CONFIG_RUST_ALLOC)]
+use core::pin::Pin;
+
+#[cfg(CONFIG_RUST_ALLOC)]
+use alloc::boxed::Box;
+
 use crate::sync::atomic::{AtomicUsize, Ordering};
 
 // The kernel object itself must be wrapped in `UnsafeCell` in Rust.  This does several thing, but
@@ -189,6 +198,41 @@ where
     }
 }
 
+/// Objects that can be fixed or allocated.
+///
+/// When using Rust threads from userspace, the `kobj_define` declarations and the complexity behind
+/// it is required.  If all Rust use of kernel objects is from system threads, and dynamic memory is
+/// available, kernel objects can be freeallocated, as long as the allocations themselves are
+/// pinned.  This `Fixed` encapsulates both of these.
+pub enum Fixed<T> {
+    /// Objects that have been statically declared and just pointed to.
+    Static(*mut T),
+    /// Objects that are owned by the wrapper, and contained here.
+    #[cfg(CONFIG_RUST_ALLOC)]
+    Owned(Pin<Box<UnsafeCell<T>>>),
+}
+
+impl<T> Fixed<T> {
+    /// Get the raw pointer out of the fixed object.
+    ///
+    /// Returns the `*mut T` pointer held by this object.  It is either just the static pointer, or
+    /// the pointer outside of the unsafe cell holding the dynamic kernel object.
+    pub fn get(&self) -> *mut T {
+        match self {
+            Fixed::Static(ptr) => *ptr,
+            #[cfg(CONFIG_RUST_ALLOC)]
+            Fixed::Owned(item) => item.get(),
+        }
+    }
+
+    /// Construct a new fixed from an allocation.  Note that the object will not be fixed in memory,
+    /// until _after_ this returns, and it should not be initialized until then.
+    #[cfg(CONFIG_RUST_ALLOC)]
+    pub fn new(item: T) -> Fixed<T> {
+        Fixed::Owned(Box::pin(UnsafeCell::new(item)))
+    }
+}
+
 /// Declare a static kernel object.  This helps declaring static values of Zephyr objects.
 ///
 /// This can typically be used as: