test(test_suite): test unmanaged interrupts

Author: yvt

src/constance_port_arm_m_test_driver/src/main.rs

@@ -101,6 +101,9 @@ macro_rules! instantiate_test {
             // Most targets should have at least four interrupt lines
             const INTERRUPT_LINES: &'static [InterruptNum] = &[16, 17, 18, 19];
             const INTERRUPT_PRIORITIES: &'static [InterruptPriority] = &[0x20, 0x60];
+
+            #[cfg(feature = "cpu-lock-by-basepri")]
+            const UNMANAGED_INTERRUPT_PRIORITIES: &'static [InterruptPriority] = &[0x00];
         }
 
         static COTTAGE: test_case::App<System> =

src/constance_test_suite/src/kernel_tests/interrupt_unmanaged.rs

@@ -0,0 +1,73 @@
+//! Makes sure that CPU Lock doesn't mask unmanaged interrupts.
+use constance::{
+    kernel::{cfg::CfgBuilder, Hunk, InterruptHandler, InterruptLine, Task},
+    prelude::*,
+};
+
+use super::Driver;
+use crate::utils::SeqTracker;
+
+pub struct App<System> {
+    int: Option<InterruptLine<System>>,
+    seq: Hunk<System, SeqTracker>,
+}
+
+impl<System: Kernel> App<System> {
+    pub const fn new<D: Driver<Self>>(b: &mut CfgBuilder<System>) -> Self {
+        Task::build()
+            .start(task_body::<System, D>)
+            .priority(0)
+            .active(true)
+            .finish(b);
+
+        let int = if let (&[int_line, ..], &[int_pri, ..]) =
+            (D::INTERRUPT_LINES, D::UNMANAGED_INTERRUPT_PRIORITIES)
+        {
+            unsafe {
+                InterruptHandler::build()
+                    .line(int_line)
+                    .unmanaged()
+                    .start(isr::<System, D>)
+                    .finish(b);
+            }
+
+            Some(
+                InterruptLine::build()
+                    .line(int_line)
+                    .priority(int_pri)
+                    .enabled(true)
+                    .finish(b),
+            )
+        } else {
+            None
+        };
+
+        let seq = Hunk::<_, SeqTracker>::build().finish(b);
+
+        App { int, seq }
+    }
+}
+
+fn task_body<System: Kernel, D: Driver<App<System>>>(_: usize) {
+    D::app().seq.expect_and_replace(0, 1);
+
+    if let Some(int) = D::app().int {
+        System::acquire_cpu_lock().unwrap();
+        D::app().seq.expect_and_replace(1, 2);
+        int.pend().unwrap();
+        D::app().seq.expect_and_replace(3, 4);
+        unsafe { System::release_cpu_lock() }.unwrap();
+        D::app().seq.expect_and_replace(4, 5);
+    } else {
+        log::warn!(
+            "No interrupt lines and compatible interrupt priorities \
+            defined, skipping the test"
+        );
+    }
+
+    D::success();
+}
+
+fn isr<System: Kernel, D: Driver<App<System>>>(_: usize) {
+    D::app().seq.expect_and_replace(2, 3);
+}

src/constance_test_suite/src/lib.rs

@@ -51,7 +51,7 @@ pub mod kernel_tests {
         /// [`pend_interrupt_line`]: constance::kernel::PortInterrupts::pend_interrupt_line
         const INTERRUPT_LINES: &'static [InterruptNum] = &[];
 
-        /// Valid priority values.
+        /// Valid managed priority values.
         ///
         ///  - The list can have an arbitrary number of elements. Some tests
         ///    will be silently skipped if it's not enough. There should be at
@@ -66,6 +66,29 @@ pub mod kernel_tests {
         ///
         /// [`MANAGED_INTERRUPT_PRIORITY_RANGE`]: constance::kernel::PortInterrupts::MANAGED_INTERRUPT_PRIORITY_RANGE
         const INTERRUPT_PRIORITIES: &'static [InterruptPriority] = &[];
+
+        /// Valid unmanaged priority values.
+        ///
+        ///  - The list can have an arbitrary number of elements. Some tests
+        ///    will be silently skipped if it's not enough. There should be at
+        ///    least one for all test cases to run.
+        ///
+        ///  - No elements must be in range
+        ///    [`MANAGED_INTERRUPT_PRIORITY_RANGE`].
+        ///
+        ///  - The elements must be sorted in a descending order of priority.
+        ///    That is, for every pair of adjacent elements `[p[i], p[i + 1]]`,
+        ///    `p[i]` should be high enough to preempt `p[o + 1]`.
+        ///
+        ///  - For every element `pri_unmanaged` in
+        ///    `UNMANAGED_INTERRUPT_PRIORITIES` and every element `pri_managed`
+        ///    in [`INTERRUPT_PRIORITIES`], `pri_unmanaged` should be high
+        ///    enough to preempt `pri_managed`.
+        ///
+        /// [`MANAGED_INTERRUPT_PRIORITY_RANGE`]: constance::kernel::PortInterrupts::MANAGED_INTERRUPT_PRIORITY_RANGE
+        /// [`INTERRUPT_PRIORITIES`]: Self::INTERRUPT_PRIORITIES
+        ///
+        const UNMANAGED_INTERRUPT_PRIORITIES: &'static [InterruptPriority] = &[];
     }
 
     macro_rules! define_kernel_tests {
@@ -159,6 +182,7 @@ pub mod kernel_tests {
         (mod interrupt_misc {}, "interrupt_misc"),
         (mod interrupt_priority {}, "interrupt_priority"),
         (mod interrupt_task_activate {}, "interrupt_task_activate"),
+        (mod interrupt_unmanaged {}, "interrupt_unmanaged"),
         (mod priority_boost {}, "priority_boost"),
         (mod semaphore_interrupt_handler {}, "semaphore_interrupt_handler"),
         (mod semaphore_misc {}, "semaphore_misc"),