zephyr-core: k_poll and k_poll_signal

Author: tylerwhall

rust/zephyr-core/src/lib.rs

@@ -8,6 +8,8 @@ pub mod kobj;
 pub mod memdomain;
 pub mod mempool;
 pub mod mutex;
+pub mod poll;
+mod poll_signal;
 pub mod semaphore;
 pub mod thread;
 mod time;

rust/zephyr-core/src/poll.rs

@@ -0,0 +1,119 @@
+use libc::{c_int, c_void};
+use zephyr_sys::raw::{
+    _poll_types_bits__POLL_TYPE_SEM_AVAILABLE, _poll_types_bits__POLL_TYPE_SIGNAL, k_poll_event,
+    k_poll_modes_K_POLL_MODE_NOTIFY_ONLY, K_POLL_TYPE_IGNORE,
+};
+
+use crate::kobj::*;
+use crate::semaphore::KSem;
+use crate::time::DurationMs;
+use crate::NegErr;
+
+pub use crate::poll_signal::*;
+
+pub type KPollEvent = k_poll_event;
+
+pub unsafe trait PollableKobj: KObj {
+    const POLL_TYPE: u32;
+}
+
+unsafe impl PollableKobj for KSem {
+    const POLL_TYPE: u32 = 1 << (_poll_types_bits__POLL_TYPE_SEM_AVAILABLE - 1);
+}
+
+unsafe impl PollableKobj for KPollSignal {
+    const POLL_TYPE: u32 = 1 << (_poll_types_bits__POLL_TYPE_SIGNAL - 1);
+}
+
+#[repr(u32)]
+pub enum PollMode {
+    NotifyOnly = k_poll_modes_K_POLL_MODE_NOTIFY_ONLY,
+}
+
+pub trait PollEventFuncs {
+    fn new() -> Self;
+
+    fn init<'e, 'o: 'e, O: PollableKobj>(&'e mut self, kobj: &'o O, mode: PollMode);
+}
+
+impl PollEventFuncs for KPollEvent {
+    fn new() -> Self {
+        unsafe {
+            let mut event = core::mem::uninitialized();
+            zephyr_sys::raw::k_poll_event_init(
+                &mut event,
+                K_POLL_TYPE_IGNORE,
+                0,
+                1 as *const c_void as *mut c_void, // Must not be null, but won't be touched by the kernel because type is IGNORE
+            );
+            event
+        }
+    }
+
+    fn init<'e, 'o: 'e, O: PollableKobj>(&'e mut self, kobj: &'o O, mode: PollMode) {
+        unsafe {
+            zephyr_sys::raw::k_poll_event_init(
+                self,
+                O::POLL_TYPE,
+                mode as c_int,
+                kobj.as_void_ptr(),
+            )
+        }
+    }
+}
+
+pub trait PollSyscalls {
+    fn k_poll(events: &mut [KPollEvent], timeout: DurationMs) -> c_int;
+}
+
+macro_rules! trait_impl {
+    ($context:ident, $context_struct:path) => {
+        impl PollSyscalls for $context_struct {
+            fn k_poll(events: &mut [KPollEvent], timeout: DurationMs) -> c_int {
+                unsafe {
+                    zephyr_sys::syscalls::$context::k_poll(
+                        events.as_mut_ptr(),
+                        events.len() as c_int,
+                        timeout.into(),
+                    )
+                }
+            }
+        }
+    };
+}
+
+trait_impl!(kernel, crate::context::Kernel);
+trait_impl!(user, crate::context::User);
+trait_impl!(any, crate::context::Any);
+
+#[derive(Clone, Copy, Debug)]
+pub enum PollError {
+    Canceled,
+}
+
+pub trait PollEventsFuncs {
+    fn poll<C: PollSyscalls>(&mut self) -> Result<(), PollError>;
+    /// Returns true if events are ready, false if timeout.
+    fn poll_timeout<C: PollSyscalls>(&mut self, timeout: DurationMs) -> Result<bool, PollError>;
+}
+
+impl PollEventsFuncs for [KPollEvent] {
+    fn poll<C: PollSyscalls>(&mut self) -> Result<(), PollError> {
+        match C::k_poll(self, zephyr_sys::raw::K_FOREVER.into()).neg_err() {
+            Ok(_) => Ok(()),
+            Err(zephyr_sys::raw::EINTR) => Err(PollError::Canceled),
+            Err(zephyr_sys::raw::ENOMEM) => panic!("k_poll OOM"),
+            Err(e) => panic!("k_poll error {}", e),
+        }
+    }
+
+    fn poll_timeout<C: PollSyscalls>(&mut self, timeout: DurationMs) -> Result<bool, PollError> {
+        match C::k_poll(self, timeout).neg_err() {
+            Ok(_) => Ok(true),
+            Err(zephyr_sys::raw::EAGAIN) => Ok(false),
+            Err(zephyr_sys::raw::EINTR) => Err(PollError::Canceled),
+            Err(zephyr_sys::raw::ENOMEM) => panic!("k_poll OOM"),
+            Err(e) => panic!("k_poll error {}", e),
+        }
+    }
+}

rust/zephyr-core/src/poll_signal.rs

@@ -0,0 +1,93 @@
+use libc::{c_int, c_uint};
+
+use crate::kobj::*;
+
+pub use zephyr_sys::raw::k_poll_signal as KPollSignal;
+
+unsafe impl KObj for KPollSignal {}
+
+crate::make_static_wrapper!(k_poll_signal, zephyr_sys::raw::k_poll_signal);
+
+pub trait KPollSignalSyscalls {
+    unsafe fn k_poll_signal_init(signal: &KPollSignal);
+    fn k_poll_signal_reset(signal: &KPollSignal);
+    fn k_poll_signal_check(signal: &KPollSignal, signaled: &mut c_uint, result: &mut c_int);
+    fn k_poll_signal_raise(signal: &KPollSignal, result: c_int) -> c_int;
+}
+
+macro_rules! trait_impl {
+    ($context:ident, $context_struct:path) => {
+        impl KPollSignalSyscalls for $context_struct {
+            unsafe fn k_poll_signal_init(signal: &KPollSignal) {
+                zephyr_sys::syscalls::$context::k_poll_signal_init(signal as *const _ as *mut _)
+            }
+
+            fn k_poll_signal_reset(signal: &KPollSignal) {
+                unsafe {
+                    zephyr_sys::syscalls::$context::k_poll_signal_reset(
+                        signal as *const _ as *mut _,
+                    )
+                }
+            }
+
+            fn k_poll_signal_check(
+                signal: &KPollSignal,
+                signaled: &mut c_uint,
+                result: &mut c_int,
+            ) {
+                unsafe {
+                    zephyr_sys::syscalls::$context::k_poll_signal_check(
+                        signal as *const _ as *mut _,
+                        signaled,
+                        result,
+                    )
+                }
+            }
+
+            fn k_poll_signal_raise(signal: &KPollSignal, result: c_int) -> c_int {
+                unsafe {
+                    zephyr_sys::syscalls::$context::k_poll_signal_raise(
+                        signal as *const _ as *mut _,
+                        result,
+                    )
+                }
+            }
+        }
+    };
+}
+
+trait_impl!(kernel, crate::context::Kernel);
+trait_impl!(user, crate::context::User);
+trait_impl!(any, crate::context::Any);
+
+pub trait Signal {
+    unsafe fn init<C: KPollSignalSyscalls>(&self);
+    fn reset<C: KPollSignalSyscalls>(&self);
+    fn check<C: KPollSignalSyscalls>(&self) -> Option<c_int>;
+    fn raise<C: KPollSignalSyscalls>(&self, result: c_int);
+}
+
+impl Signal for KPollSignal {
+    unsafe fn init<C: KPollSignalSyscalls>(&self) {
+        C::k_poll_signal_init(self)
+    }
+
+    fn reset<C: KPollSignalSyscalls>(&self) {
+        C::k_poll_signal_reset(self)
+    }
+
+    fn check<C: KPollSignalSyscalls>(&self) -> Option<c_int> {
+        let mut signaled = 0;
+        let mut result = 0;
+        C::k_poll_signal_check(self, &mut signaled, &mut result);
+        if signaled != 0 {
+            Some(result)
+        } else {
+            None
+        }
+    }
+
+    fn raise<C: KPollSignalSyscalls>(&self, result: c_int) {
+        C::k_poll_signal_raise(self, result);
+    }
+}

rust/zephyr-macros/src/lib.rs

@@ -4,19 +4,23 @@ use proc_macro::TokenStream;
 use proc_macro2::{Ident, Literal, TokenTree};
 use quote::quote;
 
-#[proc_macro]
-pub fn k_mutex_define(item: TokenStream) -> TokenStream {
+fn get_single_arg(item: TokenStream) -> Ident {
     let item = proc_macro2::TokenStream::from(item);
     let arg = item.into_iter().next();
     let ident = if let Some(TokenTree::Ident(ident)) = arg {
         ident
     } else {
         panic!(
-            "k_mutex_define takes one identifier argument. Got {:?}",
+            "k_*_define takes one identifier argument. Got {:?}",
             arg
         );
     };
+    ident
+}
 
+#[proc_macro]
+pub fn k_mutex_define(item: TokenStream) -> TokenStream {
+    let ident = get_single_arg(item);
     let section = Literal::string(&format!("._k_mutex.static.{}", ident));
     let ctor = Ident::new(&format!("_rust_mutex_init_{}", ident), ident.span());
     let ctor_ptr = Ident::new(&format!("_ctor_rust_mutex_init_{}", ident), ident.span());
@@ -42,6 +46,36 @@ pub fn k_mutex_define(item: TokenStream) -> TokenStream {
     expanded.into()
 }
 
+#[proc_macro]
+pub fn k_poll_signal_define(item: TokenStream) -> TokenStream {
+    let ident = get_single_arg(item);
+    // Using mutex section because there is not one for poll_signal. Need to
+    // ensure this is in kernel memory.
+    let section = Literal::string(&format!("._k_mutex.static.{}", ident));
+    let ctor = Ident::new(&format!("_rust_poll_signal_init_{}", ident), ident.span());
+    let ctor_ptr = Ident::new(&format!("_ctor_rust_poll_signal_init_{}", ident), ident.span());
+    let expanded = quote! {
+        // The static storage for the object, itself
+        #[link_section = #section]
+        static #ident: zephyr::poll::global::k_poll_signal = unsafe { zephyr::poll::global::k_poll_signal::uninit() };
+
+        // A constructor function that calls its init
+        #[allow(non_snake_case)]
+        extern "C" fn #ctor() {
+            use zephyr::poll::*;
+            unsafe { #ident.init::<zephyr::context::Kernel>() }
+        }
+
+        // Add a pointer to the constructor to .ctors table
+        #[used]
+        #[link_section = ".ctors"]
+        #[allow(non_upper_case_globals)]
+        static #ctor_ptr: extern "C" fn() = #ctor;
+    };
+
+    expanded.into()
+}
+
 fn get_sem_args(item: TokenStream) -> Option<(Ident, Literal, Literal)> {
     let item = proc_macro2::TokenStream::from(item);
     let mut iter = item.into_iter();