Merge branch '✨-context-queries' into 🦆

Author: yvt

src/r3/CHANGELOG.md

@@ -25,6 +25,7 @@ TODO
 ### Added
 
 - Bindings (`Bind`), a static storage with runtime initialization and configuration-time borrow checking. They can be used, for example, to provide a task or timer callback with a state data storage that can be mutably borrowed and persists across invocations.
+- `Kernel::{is_task_context, is_interrupt_context, is_boot_complete}`
 
 ### Fixed
 

src/r3_core/src/kernel/global.rs

@@ -128,6 +128,35 @@ pub trait Kernel: private::Sealed {
     /// [Priority Boost]: crate#system-states
     fn is_priority_boost_active() -> bool;
 
+    /// Return a flag indicating whether the calling context is a
+    /// [task context][].
+    ///
+    /// This is equivalent to [`is_boot_complete`][]`() &&
+    /// !`[`is_interrupt_context`][]`()`.
+    ///
+    /// [task context]: crate#contexts
+    /// [`is_boot_complete`]: Self::is_boot_complete
+    /// [`is_interrupt_context`]: Self::is_interrupt_context
+    fn is_task_context() -> bool;
+
+    /// Return a flag indicating whether the calling context is an
+    /// [interrupt context][].
+    ///
+    /// This is equivalent to [`is_boot_complete`][]`() &&
+    /// !`[`is_task_context`][]`()`.
+    ///
+    /// [interrupt context]: crate#contexts
+    /// [`is_boot_complete`]: Self::is_boot_complete
+    /// [`is_task_context`]: Self::is_task_context
+    fn is_interrupt_context() -> bool;
+
+    /// Return a flag indicating whether [the boot phase][] is complete, i.e.,
+    /// all startup hooks completed execution, and the kernel started
+    /// scheduling tasks and taking interrupts.
+    ///
+    /// [the boot phase]: crate#threads
+    fn is_boot_complete() -> bool;
+
     /// Set the current [system time].
     ///
     /// This method *does not change* the relative arrival times of outstanding
@@ -381,6 +410,21 @@ impl<T: raw::KernelBase> Kernel for T {
         <T as raw::KernelBase>::raw_is_priority_boost_active()
     }
 
+    #[inline]
+    fn is_task_context() -> bool {
+        <T as raw::KernelBase>::raw_is_task_context()
+    }
+
+    #[inline]
+    fn is_interrupt_context() -> bool {
+        <T as raw::KernelBase>::raw_is_interrupt_context()
+    }
+
+    #[inline]
+    fn is_boot_complete() -> bool {
+        <T as raw::KernelBase>::raw_is_boot_complete()
+    }
+
     #[inline]
     fn set_time(time: Time) -> Result<(), TimeError> {
         <T as raw::KernelBase>::raw_set_time(time)

src/r3_core/src/kernel/raw.rs

@@ -81,6 +81,21 @@ pub unsafe trait KernelBase: fmt::Debug + Copy + Sized + 'static {
     /// [1]: crate::kernel::Kernel::is_priority_boost_active
     fn raw_is_priority_boost_active() -> bool;
 
+    /// Implements [`Kernel::is_task_context`][1].
+    ///
+    /// [1]: crate::kernel::Kernel::is_task_context
+    fn raw_is_task_context() -> bool;
+
+    /// Implements [`Kernel::is_interrupt_context`][1].
+    ///
+    /// [1]: crate::kernel::Kernel::is_interrupt_context
+    fn raw_is_interrupt_context() -> bool;
+
+    /// Implements [`Kernel::is_boot_complete`][1].
+    ///
+    /// [1]: crate::kernel::Kernel::is_boot_complete
+    fn raw_is_boot_complete() -> bool;
+
     /// Implements [`Kernel::set_time`][1].
     ///
     /// [1]: crate::kernel::Kernel::set_time

src/r3_kernel/src/lib.rs

@@ -207,6 +207,21 @@ unsafe impl<Traits: KernelTraits> raw::KernelBase for System<Traits> {
         false
     }
 
+    #[inline]
+    fn raw_is_task_context() -> bool {
+        Traits::is_task_context()
+    }
+
+    #[inline]
+    fn raw_is_interrupt_context() -> bool {
+        Traits::is_interrupt_context()
+    }
+
+    #[inline]
+    fn raw_is_boot_complete() -> bool {
+        Traits::is_scheduler_active()
+    }
+
     #[cfg_attr(not(feature = "inline_syscall"), inline(never))]
     fn raw_set_time(time: Time) -> Result<(), r3_core::kernel::TimeError> {
         timeout::set_system_time::<Traits>(time)
@@ -503,10 +518,20 @@ pub unsafe trait PortThreading: KernelCfg1 + KernelStatic<System<Self>> {
     fn is_cpu_lock_active() -> bool;
 
     /// Return a flag indicating whether the current context is
-    /// [an task context].
+    /// [a task context].
     ///
-    /// [an task context]: crate#contexts
+    /// [a task context]: r3_core#contexts
     fn is_task_context() -> bool;
+
+    /// Return a flag indicating whether the current context is
+    /// [an interrupt context].
+    ///
+    /// [an interrupt context]: r3_core#contexts
+    fn is_interrupt_context() -> bool;
+
+    /// Return a flag indicating whether [`Self::dispatch_first_task`][] was
+    /// called.
+    fn is_scheduler_active() -> bool;
 }
 
 /// Implemented by a port. This trait contains items related to controlling

src/r3_port_arm/src/threading/cfg.rs

@@ -159,6 +159,16 @@ macro_rules! use_port {
                 fn is_task_context() -> bool {
                     <Self as PortInstance>::port_state().is_task_context::<Self>()
                 }
+
+                #[inline(always)]
+                fn is_interrupt_context() -> bool {
+                    <Self as PortInstance>::port_state().is_interrupt_context::<Self>()
+                }
+
+                #[inline(always)]
+                fn is_scheduler_active() -> bool {
+                    <Self as PortInstance>::port_state().is_scheduler_active::<Self>()
+                }
             }
         }
 

src/r3_port_arm/src/threading/imp.rs

@@ -91,6 +91,7 @@ impl State {
                 mov sp, r0
 
                 # Save the stack pointer for later use
+                # [tag:arm_main_stack_assigned_in_dft]
                 str r0, [r1]
 
                 b {push_second_level_state_and_dispatch}.dispatch
@@ -442,6 +443,18 @@ impl State {
         (cpsr & 0xf) == 0xf // System mode
     }
 
+    #[inline]
+    pub fn is_interrupt_context<Traits: PortInstance>(&self) -> bool {
+        self.is_scheduler_active::<Traits>() && !self.is_task_context::<Traits>()
+    }
+
+    #[inline]
+    pub fn is_scheduler_active<Traits: PortInstance>(&self) -> bool {
+        // `main_stack` is assigned by `dispatch_first_task`
+        // [ref:arm_main_stack_assigned_in_dft]
+        unsafe { *self.main_stack.get() != 0 }
+    }
+
     /// Implements [`crate::EntryPoint::irq_entry`]
     #[naked]
     pub unsafe extern "C" fn irq_entry<Traits: PortInstance>() -> ! {

src/r3_port_arm_m/src/threading/cfg.rs

@@ -189,6 +189,16 @@ macro_rules! use_port {
                 fn is_task_context() -> bool {
                     port_state().is_task_context::<Self>()
                 }
+
+                #[inline(always)]
+                fn is_interrupt_context() -> bool {
+                    port_state().is_interrupt_context::<Self>()
+                }
+
+                #[inline(always)]
+                fn is_scheduler_active() -> bool {
+                    port_state().is_scheduler_active::<Self>()
+                }
             }
 
             unsafe impl PortInterrupts for $Traits {

src/r3_port_arm_m/src/threading/imp.rs

@@ -83,8 +83,6 @@ impl State {
     pub unsafe fn port_boot<Traits: PortInstance>(&self) -> ! {
         unsafe { self.enter_cpu_lock::<Traits>() };
 
-        unsafe { *self.running_task_ptr.get() = Traits::state().running_task_ptr() as *mut () };
-
         // Claim the ownership of `Peripherals`
         let mut peripherals = unsafe { cortex_m::Peripherals::steal() };
 
@@ -107,6 +105,9 @@ impl State {
 
     #[inline(always)]
     pub unsafe fn dispatch_first_task<Traits: PortInstance>(&'static self) -> ! {
+        // [tag:running_task_ptr_set_in_dft]
+        unsafe { *self.running_task_ptr.get() = Traits::state().running_task_ptr() as *mut () };
+
         // Pend PendSV
         cortex_m::peripheral::SCB::set_pendsv();
 
@@ -552,6 +553,27 @@ impl State {
         cortex_m::register::control::read().spsel() == cortex_m::register::control::Spsel::Psp
     }
 
+    #[inline]
+    pub fn is_interrupt_context<Traits: PortInstance>(&self) -> bool {
+        // `IPSR.Exception != 0`
+        unsafe {
+            let ipsr: u32;
+            pp_asm!(
+                "mrs {}, ipsr",
+                out(reg) ipsr,
+                options(nomem, preserves_flags, nostack),
+            );
+            (ipsr & ((1u32 << 9) - 1)) != 0
+        }
+    }
+
+    #[inline]
+    pub fn is_scheduler_active<Traits: PortInstance>(&self) -> bool {
+        // `runnin_task_ptr` is assigned by `dispatch_first_task`
+        // [ref:running_task_ptr_set_in_dft]
+        unsafe { !(*self.running_task_ptr.get()).is_null() }
+    }
+
     pub fn set_interrupt_line_priority<Traits: PortInstance>(
         &'static self,
         num: InterruptNum,

src/r3_port_riscv/src/threading/cfg.rs

@@ -181,6 +181,16 @@ macro_rules! use_port {
                 fn is_task_context() -> bool {
                     PORT_STATE.is_task_context::<Self>()
                 }
+
+                #[inline(always)]
+                fn is_interrupt_context() -> bool {
+                    PORT_STATE.is_interrupt_context::<Self>()
+                }
+
+                #[inline(always)]
+                fn is_scheduler_active() -> bool {
+                    PORT_STATE.is_scheduler_active::<Self>()
+                }
             }
 
             unsafe impl PortInterrupts for $Traits {

src/r3_port_riscv/src/threading/imp.rs

@@ -269,6 +269,7 @@ impl State {
             pp_asm!("
             "   crate::threading::imp::asm_inc::define_load_store!()              "
                 # Save the stack pointer for later use
+                # [tag:riscv_main_stack_assigned_in_dft]
                 STORE sp, ({MAIN_STACK}), a0
 
                 # `xstatus.XPIE` will be `1` all the time except in a software
@@ -962,10 +963,23 @@ impl State {
         (Traits::Csr::xstatus().read() & Traits::Csr::XSTATUS_XIE) == 0
     }
 
+    #[inline]
     pub fn is_task_context<Traits: PortInstance>(&self) -> bool {
         unsafe { INTERRUPT_NESTING < 0 }
     }
 
+    #[inline]
+    pub fn is_interrupt_context<Traits: PortInstance>(&self) -> bool {
+        self.is_scheduler_active::<Traits>() && !self.is_task_context::<Traits>()
+    }
+
+    #[inline]
+    pub fn is_scheduler_active<Traits: PortInstance>(&self) -> bool {
+        // `MAIN_STACK` is assigned by `dispatch_first_task`
+        // [ref:riscv_main_stack_assigned_in_dft]
+        unsafe { MAIN_STACK != 0 }
+    }
+
     pub fn set_interrupt_line_priority<Traits: PortInstance>(
         &'static self,
         num: InterruptNum,