zephyr: Convert Queue to new atomic initializer up

Convert to the new atomic initializer format. This makes the `new()`
constructor `const` allowing queues to be used as statics.

Similar to the API change to Semaphore, the constructor no longer
returns a Result, just the Queue directly.

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

Author: d3zd3z

zephyr/src/sync/channel.rs

@@ -93,7 +93,7 @@ pub fn unbounded_from<T>(queue: Queue) -> (Sender<T>, Receiver<T>) {
 /// receivers will likely be blocked forever.  Any data that has been queued and not received will
 /// be leaked when all receivers have been droped.
 pub fn unbounded<T>() -> (Sender<T>, Receiver<T>) {
-    unbounded_from(Queue::new().unwrap())
+    unbounded_from(Queue::new())
 }
 
 /// Create a multi-producer multi-consumer channel with bounded capacity.
@@ -582,8 +582,8 @@ impl<T> Bounded<T> {
             .collect();
         let slots = Box::into_pin(slots);
 
-        let free = Queue::new().unwrap();
-        let chan = Queue::new().unwrap();
+        let free = Queue::new();
+        let chan = Queue::new();
 
         // Add each of the boxes to the free list.
         for slot in slots.as_ref().iter() {

zephyr/src/sys/queue.rs

@@ -6,22 +6,14 @@
 
 use core::ffi::c_void;
 use core::fmt;
-#[cfg(CONFIG_RUST_ALLOC)]
-use core::mem;
 
 use zephyr_sys::{k_queue, k_queue_append, k_queue_get, k_queue_init};
 
-#[cfg(CONFIG_RUST_ALLOC)]
-use crate::error::Result;
-use crate::object::{Fixed, StaticKernelObject, Wrapped};
+use crate::object::{ObjectInit, ZephyrObject};
 use crate::time::Timeout;
 
 /// A wrapper around a Zephyr `k_queue` object.
-pub struct Queue {
-    pub(crate) item: Fixed<k_queue>,
-}
-
-unsafe impl Sync for StaticKernelObject<k_queue> {}
+pub struct Queue(pub(crate) ZephyrObject<k_queue>);
 
 unsafe impl Sync for Queue {}
 unsafe impl Send for Queue {}
@@ -33,13 +25,8 @@ impl Queue {
     ///
     /// **Note**: When a Queue is dropped, any messages that have been added to the queue will be
     /// leaked.
-    #[cfg(CONFIG_RUST_ALLOC)]
-    pub fn new() -> Result<Queue> {
-        let item: Fixed<k_queue> = Fixed::new(unsafe { mem::zeroed() });
-        unsafe {
-            k_queue_init(item.get());
-        }
-        Ok(Queue { item })
+    pub const fn new() -> Queue {
+        Queue(<ZephyrObject<k_queue>>::new_raw())
     }
 
     /// Append an element to the end of a queue.
@@ -61,7 +48,7 @@ impl Queue {
     /// These are easiest to satisfy by ensuring the message is Boxed, and owned by the queue
     /// system.
     pub unsafe fn send(&self, data: *mut c_void) {
-        k_queue_append(self.item.get(), data)
+        k_queue_append(self.0.get(), data)
     }
 
     /// Get an element from a queue.
@@ -84,42 +71,22 @@ impl Queue {
         T: Into<Timeout>,
     {
         let timeout: Timeout = timeout.into();
-        k_queue_get(self.item.get(), timeout.0)
+        k_queue_get(self.0.get(), timeout.0)
     }
 }
 
-impl Wrapped for StaticKernelObject<k_queue> {
-    type T = Queue;
-
-    type I = ();
-
-    fn get_wrapped(&self, _arg: Self::I) -> Queue {
-        let ptr = self.value.get();
+impl ObjectInit<k_queue> for ZephyrObject<k_queue> {
+    fn init(item: *mut k_queue) {
+        // SAFETY: ZephyrObject handles initialization and move prevention.
         unsafe {
-            k_queue_init(ptr);
-        }
-        Queue {
-            item: Fixed::Static(ptr),
+            k_queue_init(item);
         }
     }
 }
 
-/// A statically defined Zephyr `k_queue`.
-///
-/// This should be declared as follows:
-/// ```
-/// kobj_define! {
-///     static MY_QUEUE: StaticQueue;
-/// }
-///
-/// let my_queue = MY_QUEUE.init_once(());
-///
-/// my_queue.send(...);
-/// ```
-pub type StaticQueue = StaticKernelObject<k_queue>;
-
 impl fmt::Debug for Queue {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "sys::Queue {:?}", self.item.get())
+        // SAFETY: Just getting the address to print.
+        write!(f, "sys::Queue {:?}", unsafe { self.0.get() })
     }
 }

zephyr/src/work/futures.rs

@@ -339,7 +339,7 @@ impl WakeInfo {
                 ev.get(),
                 ZR_POLL_TYPE_DATA_AVAILABLE,
                 k_poll_modes_K_POLL_MODE_NOTIFY_ONLY as i32,
-                queue.item.get() as *mut c_void,
+                queue.0.get() as *mut c_void,
             );
         }
     }