zephyr: sys: sync: sempahore: Add dynamic support

Add support for dynamically allocated Semaphores.  These can be freely
allocated, but are not usable from userspace.

Author: d3zd3z

zephyr/src/sys/sync/semaphore.rs

@@ -13,17 +13,13 @@
 
 use core::ffi::c_uint;
 use core::fmt;
+use core::mem;
 
 use crate::{
-    error::{Result, to_result_void},
-    object::{StaticKernelObject, Wrapped},
+    error::{to_result_void, Result},
+    object::{Fixed, StaticKernelObject, Wrapped},
     raw::{
-        k_sem,
-        k_sem_init,
-        k_sem_take,
-        k_sem_give,
-        k_sem_reset,
-        k_sem_count_get,
+        k_sem, k_sem_count_get, k_sem_give, k_sem_init, k_sem_reset, k_sem_take
     },
     time::Timeout,
 };
@@ -33,7 +29,7 @@ pub use crate::raw::K_SEM_MAX_LIMIT;
 /// A zephyr `k_sem` usable from safe Rust code.
 pub struct Semaphore {
     /// The raw Zephyr `k_sem`.
-    item: *mut k_sem,
+    item: Fixed<k_sem>,
 }
 
 /// By nature, Semaphores are both Sync and Send.  Safety is handled by the underlying Zephyr
@@ -42,6 +38,20 @@ unsafe impl Sync for Semaphore {}
 unsafe impl Send for Semaphore {}
 
 impl Semaphore {
+    /// Create a new semaphore.
+    ///
+    /// Create a new dynamically allocated Semaphore.  This semaphore can only be used from system
+    /// threads.  The arguments are as described in [the
+    /// docs](https://docs.zephyrproject.org/latest/kernel/services/synchronization/semaphores.html).
+    #[cfg(CONFIG_RUST_ALLOC)]
+    pub fn new(initial_count: c_uint, limit: c_uint) -> Result<Semaphore> {
+        let item: Fixed<k_sem> = Fixed::new(unsafe { mem::zeroed() });
+        unsafe {
+            to_result_void(k_sem_init(item.get(), initial_count, limit))?;
+        }
+        Ok(Semaphore { item })
+    }
+
     /// Take a semaphore.
     ///
     /// Can be called from ISR if called with [`NoWait`].
@@ -52,7 +62,7 @@ impl Semaphore {
     {
         let timeout: Timeout = timeout.into();
         let ret = unsafe {
-            k_sem_take(self.item, timeout.0)
+            k_sem_take(self.item.get(), timeout.0)
         };
         to_result_void(ret)
     }
@@ -63,7 +73,7 @@ impl Semaphore {
     /// permitted count.
     pub fn give(&self) {
         unsafe {
-            k_sem_give(self.item)
+            k_sem_give(self.item.get())
         }
     }
 
@@ -75,7 +85,7 @@ impl Semaphore {
     /// [`take`]: Self::take
     pub fn reset(&mut self) {
         unsafe {
-            k_sem_reset(self.item)
+            k_sem_reset(self.item.get())
         }
     }
 
@@ -84,7 +94,7 @@ impl Semaphore {
     /// Returns the current count.
     pub fn count_get(&mut self) -> usize {
         unsafe {
-            k_sem_count_get(self.item) as usize
+            k_sem_count_get(self.item.get()) as usize
         }
     }
 }
@@ -114,7 +124,7 @@ impl Wrapped for StaticKernelObject<k_sem> {
             k_sem_init(ptr, arg.0, arg.1);
         }
         Semaphore {
-            item: ptr,
+            item: Fixed::Static(ptr),
         }
     }
 }