zephyr: sys: queue: Add timeout to queue recv

Add an argument to the `recv` method on Queue to allow a timeout to be
specified.  This will allow channels to have timeout variants available.

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

Author: d3zd3z

zephyr/src/sync/channel.rs

@@ -22,6 +22,7 @@ use core::marker::PhantomData;
 use core::mem::MaybeUninit;
 
 use crate::sys::queue::Queue;
+use crate::time::Forever;
 
 mod counter;
 
@@ -130,7 +131,7 @@ impl<T> Sender<T> {
             }
             SenderFlavor::Bounded(chan) => {
                 // Retrieve a message buffer from the free list.
-                let buf = unsafe { chan.free.recv() };
+                let buf = unsafe { chan.free.recv(Forever) };
                 let buf = buf as *mut Message<T>;
                 unsafe {
                     buf.write(Message::new(msg));
@@ -217,15 +218,15 @@ impl<T> Receiver<T> {
         match &self.flavor {
             ReceiverFlavor::Unbounded { queue, .. } => {
                 let msg = unsafe {
-                    queue.recv()
+                    queue.recv(Forever)
                 };
                 let msg = msg as *mut Message<T>;
                 let msg = unsafe { Box::from_raw(msg) };
                 Ok(msg.data)
             }
             ReceiverFlavor::Bounded(chan) => {
                 let rawbuf = unsafe {
-                    chan.chan.recv()
+                    chan.chan.recv(Forever)
                 };
                 let buf = rawbuf as *mut Message<T>;
                 let msg: Message<T> = unsafe { buf.read() };

zephyr/src/sys/queue.rs

@@ -18,8 +18,8 @@ use zephyr_sys::{
 
 #[cfg(CONFIG_RUST_ALLOC)]
 use crate::error::Result;
-use crate::sys::K_FOREVER;
 use crate::object::{Fixed, StaticKernelObject, Wrapped};
+use crate::time::Timeout;
 
 /// A wrapper around a Zephyr `k_queue` object.
 pub struct Queue {
@@ -62,8 +62,14 @@ impl Queue {
     /// Get an element from a queue.
     ///
     /// This routine removes the first data item from the [`Queue`].
-    pub unsafe fn recv(&self) -> *mut c_void {
-        k_queue_get(self.item.get(), K_FOREVER)
+    /// The timeout value can be [`Forever`] to block until there is a message, [`NoWait`] to check
+    /// and immediately return if there is no message, or a [`Duration`] to indicate a specific
+    /// timeout.
+    pub unsafe fn recv<T>(&self, timeout: T) -> *mut c_void
+        where T: Into<Timeout>
+    {
+        let timeout: Timeout = timeout.into();
+        k_queue_get(self.item.get(), timeout.0)
     }
 }