feat(port_std): support true asynchronous interrupts

Author: yvt

src/constance_port_std/src/lib.md

@@ -56,6 +56,4 @@ Based on the internal user-mode scheduling (UMS) framework, we treat interrupt h
 
 The interrupt line [`INTERRUPT_LINE_DISPATCH`] is reserved for the dispatcher.
 
-**To be implemented:** True asynchronous interrupts aren't supported yet.
-
 [`INTERRUPT_LINE_DISPATCH`]: crate::INTERRUPT_LINE_DISPATCH

src/constance_port_std/src/lib.rs

@@ -546,6 +546,32 @@ pub fn shutdown<System: PortInstance>() {
         .shutdown();
 }
 
+/// Pend an interrupt line from an external thread.
+///
+/// It's illegal to call this method from a thread managed by the port (i.e.,
+/// you can't call it from a task or an interrupt handler). Use
+/// [`constance::kernel::InterruptLine::pend`] instead in such cases.
+pub fn pend_interrupt_line<System: PortInstance>(
+    num: InterruptNum,
+) -> Result<(), PendInterruptLineError> {
+    log::trace!("external-pend_interrupt_line{:?}", (num,));
+
+    assert_eq!(THREAD_ROLE.with(|r| r.get()), ThreadRole::Unknown);
+
+    let state = System::port_state();
+    let mut lock = state.thread_group.get().unwrap().lock();
+    lock.scheduler()
+        .update_line(num, |line| line.pended = true)
+        .map_err(|sched::BadIntLineError| PendInterruptLineError::BadParam)?;
+
+    if sched::check_preemption_by_interrupt(state.thread_group.get().unwrap(), &mut lock) {
+        lock.preempt();
+        drop(lock);
+    }
+
+    Ok(())
+}
+
 #[macro_export]
 macro_rules! use_port {
     (unsafe $vis:vis struct $sys:ident) => {

src/constance_port_std/tests/kernel_tests/external_interrupt.rs

@@ -0,0 +1,68 @@
+//! Pends an interrupt from an external thread.
+use constance::{
+    kernel::{Hunk, InterruptHandler, InterruptLine, Task},
+    prelude::*,
+};
+use constance_test_suite::kernel_tests::Driver;
+use std::{
+    sync::atomic::{AtomicBool, Ordering},
+    thread::{sleep, spawn},
+    time::Duration,
+};
+
+use constance_port_std::PortInstance;
+
+pub struct App<System> {
+    int: Option<InterruptLine<System>>,
+    done: Hunk<System, AtomicBool>,
+}
+
+impl<System: PortInstance> 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 int = if let [int_line, ..] = *D::INTERRUPT_LINES {
+                new! { InterruptHandler<_>,
+                    line = int_line, start = isr::<System, D>};
+
+                Some(new! { InterruptLine<_>,
+                    line = int_line, priority = D::INTERRUPT_PRIORITY_LOW , enabled = true })
+            } else {
+                None
+            };
+
+            let done = new! { Hunk<_, AtomicBool> };
+
+            App { int, done }
+        }
+    }
+}
+
+fn task_body1<System: PortInstance, 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;
+    };
+
+    // Spawn a host thread
+    log::debug!("spawning an external thread");
+    spawn(move || {
+        sleep(Duration::from_millis(100));
+        log::debug!("pending {:?}", int);
+        constance_port_std::pend_interrupt_line::<System>(int.num()).unwrap();
+    });
+
+    log::debug!("waiting for `done` to be set...");
+    while !D::app().done.load(Ordering::Relaxed) {}
+    log::debug!("success!");
+
+    D::success();
+}
+
+fn isr<System: Kernel, D: Driver<App<System>>>(_: usize) {
+    D::app().done.store(true, Ordering::Relaxed);
+}

src/constance_port_std/tests/test_suite.rs

@@ -3,6 +3,7 @@
 #![feature(const_if_match)]
 #![feature(never_type)]
 #![feature(const_mut_refs)]
+#![feature(const_fn)]
 
 use constance_port_std::PortInstance;
 use std::sync::atomic::{AtomicBool, Ordering};
@@ -42,8 +43,22 @@ impl KernelTestUtil {
     }
 }
 
+mod kernel_tests {
+    pub mod external_interrupt;
+}
+
 macro_rules! instantiate_kernel_tests {
-    ($(
+    ( $( { $($tt:tt)* }, )* ) => {
+        instantiate_kernel_tests!(
+            @inner
+
+            $( { $($tt)* }, )*
+
+            // Port-specific tests
+            { path: crate::kernel_tests::external_interrupt, name_ident: external_interrupt, },
+        );
+    };
+    ( @inner $(
         { path: $path:path, name_ident: $name_ident:ident, $($rest:tt)* },
     )*) => {$(
         mod $name_ident {