fix(port_std): handle the interrupt context case in yield_cpu

Author: yvt

src/constance_port_std/src/lib.rs

@@ -445,6 +445,12 @@ impl State {
         log::trace!("yield_cpu");
         assert!(!self.is_cpu_lock_active());
 
+        // The dispatcher will automatically run when the current interrupt
+        // handler returns the control to it
+        if self.is_interrupt_context() {
+            return;
+        }
+
         self.yield_cpu_inner::<System>();
     }
 

src/constance_test_suite/src/kernel_tests/interrupt_task_activate.rs

@@ -0,0 +1,56 @@
+//! Checks the return codes of disallowed system calls made in an interrupt
+//! context.
+use constance::{
+    kernel::{InterruptHandler, InterruptLine, Task},
+    prelude::*,
+};
+
+use super::Driver;
+
+#[derive(Debug)]
+pub struct App<System> {
+    task2: Task<System>,
+    int: Option<InterruptLine<System>>,
+}
+
+impl<System: Kernel> App<System> {
+    constance::configure! {
+        pub const fn new<D: Driver<Self>>(_: &mut CfgBuilder<System>) -> Self {
+            new! { Task<_>, start = task_body1::<System, D>, priority = 1, active = true };
+            let task2 = new! { Task<_>, start = task_body2::<System, D>, priority = 0 };
+
+            let int = if let [int_line, ..] = *D::INTERRUPT_LINES {
+                unsafe {
+                    new! { InterruptHandler<_>,
+                        line = int_line, start = isr::<System, D>, unmanaged };
+                }
+
+                Some(new! { InterruptLine<_>, line = int_line, enabled = true })
+            } else {
+                None
+            };
+
+            App { task2, int }
+        }
+    }
+}
+
+fn task_body1<System: Kernel, D: Driver<App<System>>>(_: usize) {
+    let int = if let Some(int) = D::app().int {
+        int
+    } else {
+        log::warn!("No interrupt lines defined, skipping the test");
+        D::success();
+        return;
+    };
+
+    int.pend().unwrap();
+}
+
+fn isr<System: Kernel, D: Driver<App<System>>>(_: usize) {
+    D::app().task2.activate().unwrap();
+}
+
+fn task_body2<System: Kernel, D: Driver<App<System>>>(_: usize) {
+    D::success();
+}

src/constance_test_suite/src/lib.rs

@@ -148,6 +148,7 @@ pub mod kernel_tests {
         (mod interrupt_disallowed_services {}, "interrupt_disallowed_services"),
         (mod interrupt_misc {}, "interrupt_misc"),
         (mod interrupt_priority {}, "interrupt_priority"),
+        (mod interrupt_task_activate {}, "interrupt_task_activate"),
         (mod priority_boost {}, "priority_boost"),
         (mod task_activate_and_dispatch {}, "task_activate_and_dispatch"),
         (mod task_activate_and_do_not_dispatch {}, "task_activate_and_do_not_dispatch"),