[wip] add ipi for aarch64

Author: hky1999

Cargo.lock

@@ -15,6 +15,7 @@ members = [
     "modules/axruntime",
     "modules/axsync",
     "modules/axtask",
+    "modules/axipi",
 
     "api/axfeat",
     "api/arceos_api",
@@ -61,6 +62,7 @@ axruntime = { path = "modules/axruntime" }
 axsync = { path = "modules/axsync" }
 axtask = { path = "modules/axtask" }
 axdma = { path = "modules/axdma" }
+axipi = { path = "modules/axipi" }
 
 [profile.release]
 lto = true

Cargo.toml

@@ -20,6 +20,7 @@ fp_simd = ["axhal/fp_simd"]
 
 # Interrupts
 irq = ["axhal/irq", "axruntime/irq", "axtask?/irq"]
+ipi = ["axruntime/ipi"]
 
 # Memory
 alloc = ["axalloc", "axruntime/alloc"]

api/axfeat/Cargo.toml

@@ -10,7 +10,7 @@ repository = "https://github.com/arceos-org/arceos/tree/main/modules/axhal"
 documentation = "https://arceos-org.github.io/arceos/axhal/index.html"
 
 [features]
-smp = []
+smp = ["dep:cpumask"]
 alloc = []
 fp_simd = []
 paging = ["axalloc", "page_table_multiarch"]
@@ -39,6 +39,7 @@ axlog = { workspace = true }
 axconfig = { workspace = true }
 axalloc = { workspace = true, optional = true }
 cortex-a = { version = "8.1.1", optional = true }
+cpumask = { version = "0.1", optional = true }
 
 [target.'cfg(target_arch = "x86_64")'.dependencies]
 x86 = "0.52"

modules/axhal/Cargo.toml

@@ -5,7 +5,7 @@ use handler_table::HandlerTable;
 use crate::platform::irq::{dispatch_irq, MAX_IRQ_COUNT};
 use crate::trap::{register_trap_handler, IRQ};
 
-pub use crate::platform::irq::{register_handler, set_enable};
+pub use crate::platform::irq::{register_handler, set_enable, IPI_IRQ_NUM};
 
 #[cfg(target_arch = "aarch64")]
 pub use crate::platform::irq::fetch_irq;

modules/axhal/src/irq.rs

@@ -17,6 +17,9 @@ pub const TIMER_IRQ_NUM: usize = translate_irq(10, InterruptType::PPI).unwrap();
 /// The UART IRQ number.
 pub const UART_IRQ_NUM: usize = translate_irq(axconfig::UART_IRQ, InterruptType::SPI).unwrap();
 
+/// The IPI IRQ number.
+pub const IPI_IRQ_NUM: usize = translate_irq(1, InterruptType::SGI).unwrap();
+
 const GICD_BASE: PhysAddr = pa!(axconfig::GICD_PADDR);
 const GICC_BASE: PhysAddr = pa!(axconfig::GICC_PADDR);
 
@@ -41,6 +44,12 @@ pub fn register_handler(irq_num: usize, handler: IrqHandler) -> bool {
     crate::irq::register_handler_common(irq_num, handler)
 }
 
+/// Sends Software Generated Interrupt (SGI)(s) (usually IPI) to the given CPUs.
+#[cfg(feature = "smp")]
+pub fn send_sgi(cpu_if: usize, irq_num: usize) {
+    GICD.lock().send_sgi(cpu_if, irq_num);
+}
+
 /// Fetches the IRQ number.
 pub fn fetch_irq() -> usize {
     GICC.iar() as usize

modules/axhal/src/platform/aarch64_common/gic.rs

@@ -26,7 +26,9 @@ cfg_if::cfg_if! {
         mod aarch64_rk3588j;
         pub use self::aarch64_rk3588j::*;
     } else {
-        mod dummy;
-        pub use self::dummy::*;
+        // mod dummy;
+        // pub use self::dummy::*;
+        mod aarch64_qemu_virt;
+        pub use self::aarch64_qemu_virt::*;
     }
 }

modules/axhal/src/platform/mod.rs

@@ -0,0 +1,22 @@
+[package]
+name = "axipi"
+edition = "2021"
+version.workspace = true
+authors = ["Keyang Hu <keyang.hu@qq.com>"]
+description = "ArceOS IPI management module"
+license.workspace = true
+homepage.workspace = true
+# repository = "https://github.com/arceos-org/arceos/tree/main/modules/axipi"
+# documentation = "https://arceos-org.github.io/arceos/axipi/index.html"
+
+[features]
+default = []
+
+[dependencies]
+log = "=0.4.21"
+lazyinit = { version = "0.2" }
+
+percpu = { version = "0.1.5" }
+kspin = { version = "0.1" }
+
+axhal = { workspace = true }

modules/axipi/Cargo.toml

@@ -0,0 +1,39 @@
+extern crate alloc;
+
+use lazyinit::LazyInit;
+
+use kspin::SpinNoIrq;
+
+use axhal::cpu::this_cpu_id;
+use axhal::irq::IPI_IRQ_NUM;
+
+mod queue;
+
+use queue::IPIEventQueue;
+
+pub use queue::IPIEventFn;
+
+#[percpu::def_percpu]
+static IPI_MSG_QUEUE: LazyInit<SpinNoIrq<IPIEventQueue<IPIEventFn>>> = LazyInit::new();
+
+pub fn init() {
+    IPI_MSG_QUEUE.with_current(|ipi_queue| {
+        ipi_queue.init_once(SpinNoIrq::new(IPIEventQueue::default()));
+    });
+    axhal::irq::register_handler(IPI_IRQ_NUM, ipi_handler);
+}
+
+pub fn send_ipi_event(target_cpu: usize, event: IPIEventFn) {
+    unsafe { IPI_MSG_QUEUE.remote_ref_raw(target_cpu) }
+        .lock()
+        .push(this_cpu_id(), event);
+}
+
+fn ipi_handler() {
+    while let Some(event) = unsafe { IPI_MSG_QUEUE.current_ref_mut_raw() }
+        .lock()
+        .pop_one()
+    {
+        event();
+    }
+}

modules/axipi/src/lib.rs

@@ -0,0 +1,77 @@
+use alloc::collections::VecDeque;
+
+/// A queue of IPI events.
+///
+/// It internally uses a `VecDeque` to store the events, make it
+/// possible to pop these events using FIFO order.
+pub struct IPIEventQueue<E: IPIEvent> {
+    events: VecDeque<IPIEventWrapper<E>>,
+}
+
+/// A trait that all events must implement.
+pub trait IPIEvent: 'static {
+    /// Callback function that will be called when the event is triggered.
+    fn callback(self);
+}
+
+struct IPIEventWrapper<E> {
+    src_cpu_id: u32,
+    event: E,
+}
+
+impl<E: IPIEvent> IPIEventQueue<E> {
+    /// Creates a new empty timer list.
+    pub fn new() -> Self {
+        Self {
+            events: VecDeque::new(),
+        }
+    }
+
+    /// Whether there is no event.
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.events.is_empty()
+    }
+
+    pub fn push(&mut self, src_cpu_id: u32, event: E) {
+        self.events.push_back(IPIEventWrapper { src_cpu_id, event });
+    }
+
+    /// Try to pop the latest event that exists in the queue.
+    ///
+    /// Returns `None` if no event is available.
+    pub fn pop_one(&mut self) -> Option<E> {
+        if let Some(e) = self.events.pop_front() {
+            Some(e.event)
+        } else {
+            None
+        }
+    }
+}
+
+impl<E: IPIEvent> Default for IPIEventQueue<E> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+/// A simple wrapper of a closure that implements the [`IPIEvent`] trait.
+///
+/// So that it can be used as in the [`IPIEventQueue`].
+pub struct IPIEventFn(Box<dyn FnOnce() + 'static>);
+
+impl IPIEventFn {
+    /// Constructs a new [`IPIEventFn`] from a closure.
+    pub fn new<F>(f: F) -> Self
+    where
+        F: FnOnce() + 'static,
+    {
+        Self(Box::new(f))
+    }
+}
+
+impl IPIEvent for IPIEventFn {
+    fn callback(self) {
+        (self.0)()
+    }
+}