add new module axipi (arceos-org#283)

Josen-B · hky1999 · aarkegz · web-flow · commit ba1fd722cb10 · 2025-08-21T13:18:10.000+08:00
---------

Co-authored-by: hky1999 &lt;976929993@qq.com&gt;
Co-authored-by: aarkegz &lt;aarkegz@gmail.com&gt;
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -16,6 +16,7 @@ members = [
     "modules/axruntime",
     "modules/axsync",
     "modules/axtask",
+    "modules/axipi",
 
     "api/axfeat",
     "api/arceos_api",
@@ -65,6 +66,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
diff --git a/api/arceos_api/Cargo.toml b/api/arceos_api/Cargo.toml
@@ -13,6 +13,7 @@ documentation = "https://arceos-org.github.io/arceos/arceos_api/index.html"
 default = []
 
 irq = ["axfeat/irq"]
+ipi = ["dep:axipi", "axfeat/ipi"]
 alloc = ["dep:axalloc", "axfeat/alloc"]
 paging = ["dep:axmm", "axfeat/paging"]
 dma = ["dep:axdma", "axfeat/dma"]
@@ -43,3 +44,4 @@ axdriver = { workspace = true, optional = true }
 axfs = { workspace = true, optional = true }
 axnet = { workspace = true, optional = true }
 axdisplay = { workspace = true, optional = true }
+axipi = { workspace = true, optional = true }
diff --git a/api/arceos_api/src/lib.rs b/api/arceos_api/src/lib.rs
@@ -402,6 +402,8 @@ pub mod modules {
     pub use axdriver;
     #[cfg(feature = "fs")]
     pub use axfs;
+    #[cfg(feature = "ipi")]
+    pub use axipi;
     #[cfg(feature = "paging")]
     pub use axmm;
     #[cfg(feature = "net")]
diff --git a/api/axfeat/Cargo.toml b/api/axfeat/Cargo.toml
@@ -20,6 +20,7 @@ fp-simd = ["axhal/fp-simd"]
 
 # Interrupts
 irq = ["axhal/irq", "axruntime/irq", "axtask?/irq"]
+ipi = ["irq", "dep:axipi", "axhal/ipi", "axruntime/ipi"]
 
 # Custom or default platforms
 myplat = ["axhal/myplat"]
@@ -82,4 +83,5 @@ axnet = { workspace = true, optional = true }
 axdisplay = { workspace = true, optional = true }
 axsync = { workspace = true, optional = true }
 axtask = { workspace = true, optional = true }
+axipi = { workspace = true, optional = true }
 kspin = { version = "0.1", optional = true }
diff --git a/api/axfeat/src/lib.rs b/api/axfeat/src/lib.rs
@@ -7,6 +7,7 @@
 //!     - `fp-simd`: Enable floating point and SIMD support.
 //! - Interrupts:
 //!     - `irq`: Enable interrupt handling support.
+//!     - `ipi`: Enable Inter-Processor Interrupts (IPIs).
 //! - Memory
 //!     - `alloc`: Enable dynamic memory allocation.
 //!     - `alloc-tlsf`: Use the TLSF allocator.
diff --git a/configs/custom/x86_64-pc-oslab.toml b/configs/custom/x86_64-pc-oslab.toml
@@ -57,3 +57,5 @@ pci-ranges = []                 # [(uint, uint)]
 timer-frequency = 4_000_000_000     # uint
 # Timer interrupt num.
 timer-irq = 0xf0                    # uint
+# IPI interrupt num
+ipi-irq = 0xf3                      # uint
diff --git a/configs/dummy.toml b/configs/dummy.toml
@@ -54,3 +54,5 @@ pci-bus-end = 0             # uint
 pci-ranges = []             # [(uint, uint)]
 # Timer interrupt num.
 timer-irq = 0               # uint
+# IPI interrupt num
+ipi-irq = 0                 # uint
diff --git a/examples/helloworld-myplat/Cargo.toml b/examples/helloworld-myplat/Cargo.toml
@@ -18,16 +18,16 @@ cfg-if = "1.0"
 axstd = { workspace = true, features = ["myplat"], optional = true }
 
 [target.'cfg(target_arch = "x86_64")'.dependencies]
-axplat-x86-pc = { version = "0.1", features = ["smp", "irq"], optional = true }
+axplat-x86-pc = { version = "0.2", features = ["smp", "irq"], optional = true }
 
 [target.'cfg(target_arch = "aarch64")'.dependencies]
-axplat-aarch64-qemu-virt = { version = "0.1", features = ["smp", "irq"], optional = true }
-axplat-aarch64-raspi = { version = "0.1", features = ["smp", "irq"], optional = true }
-axplat-aarch64-bsta1000b = { version = "0.1", features = ["smp", "irq"], optional = true }
-axplat-aarch64-phytium-pi = { version = "0.1", features = ["smp", "irq"], optional = true }
+axplat-aarch64-qemu-virt = { version = "0.2", features = ["smp", "irq"], optional = true }
+axplat-aarch64-raspi = { version = "0.2", features = ["smp", "irq"], optional = true }
+axplat-aarch64-bsta1000b = { version = "0.2", features = ["smp", "irq"], optional = true }
+axplat-aarch64-phytium-pi = { version = "0.2", features = ["smp", "irq"], optional = true }
 
 [target.'cfg(target_arch = "riscv64")'.dependencies]
-axplat-riscv64-qemu-virt = { version = "0.1", features = ["smp", "irq"], optional = true }
+axplat-riscv64-qemu-virt = { version = "0.2", features = ["smp", "irq"], optional = true }
 
 [target.'cfg(target_arch = "loongarch64")'.dependencies]
-axplat-loongarch64-qemu-virt = { version = "0.1", features = ["smp", "irq"], optional = true }
+axplat-loongarch64-qemu-virt = { version = "0.2", features = ["smp", "irq"], optional = true }
diff --git a/modules/axhal/Cargo.toml b/modules/axhal/Cargo.toml
@@ -23,6 +23,7 @@ myplat = []
 defplat = ["dep:axplat-x86-pc", "dep:axplat-aarch64-qemu-virt", "dep:axplat-riscv64-qemu-virt", "dep:axplat-loongarch64-qemu-virt"]
 
 default = []
+ipi = ["irq"]
 
 [dependencies]
 log = "=0.4.21"
@@ -35,24 +36,23 @@ memory_addr = "0.4"
 linkme = { version = "0.3.33", optional = true }
 page_table_multiarch = { version = "0.5", features = ["copy-from"], optional = true }
 axcpu = "0.2"
-axplat = "0.1"
-
+axplat = "0.2"
 axlog = { workspace = true }
 axconfig = { workspace = true }
 axalloc = { workspace = true, optional = true }
 
 [target.'cfg(target_arch = "x86_64")'.dependencies]
-axplat-x86-pc = { version = "0.1", optional = true }
+axplat-x86-pc = { version = "0.2", optional = true }
 
 [target.'cfg(target_arch = "aarch64")'.dependencies]
 aarch64-cpu = "10.0"
-axplat-aarch64-qemu-virt = { version = "0.1", optional = true }
+axplat-aarch64-qemu-virt = { version = "0.2", optional = true }
 
 [target.'cfg(target_arch = "riscv64")'.dependencies]
-axplat-riscv64-qemu-virt = { version = "0.1", optional = true }
+axplat-riscv64-qemu-virt = { version = "0.2", optional = true }
 
 [target.'cfg(target_arch = "loongarch64")'.dependencies]
-axplat-loongarch64-qemu-virt = { version = "0.1", optional = true }
+axplat-loongarch64-qemu-virt = { version = "0.2", optional = true }
 
 [build-dependencies]
 axconfig = { workspace = true }
diff --git a/modules/axhal/src/dummy.rs b/modules/axhal/src/dummy.rs
@@ -5,7 +5,7 @@ use axplat::impl_plat_interface;
 use axplat::console::ConsoleIf;
 use axplat::init::InitIf;
 #[cfg(feature = "irq")]
-use axplat::irq::{IrqHandler, IrqIf};
+use axplat::irq::{IpiTarget, IrqHandler, IrqIf};
 use axplat::mem::{MemIf, RawRange};
 use axplat::power::PowerIf;
 use axplat::time::TimeIf;
@@ -111,4 +111,6 @@ impl IrqIf for DummyIrq {
     }
 
     fn handle(_irq: usize) {}
+
+    fn send_ipi(_irq: usize, _target: IpiTarget) {}
 }
diff --git a/modules/axhal/src/irq.rs b/modules/axhal/src/irq.rs
@@ -4,6 +4,12 @@ use axcpu::trap::{IRQ, register_trap_handler};
 
 pub use axplat::irq::{handle, register, set_enable, unregister};
 
+#[cfg(feature = "ipi")]
+pub use axplat::irq::{IpiTarget, send_ipi};
+
+#[cfg(feature = "ipi")]
+pub use axconfig::devices::IPI_IRQ;
+
 /// IRQ handler.
 ///
 /// # Warn
diff --git a/modules/axipi/Cargo.toml b/modules/axipi/Cargo.toml
@@ -0,0 +1,21 @@
+[package]
+name = "axipi"
+version.workspace = true
+edition.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"
+kspin = { version = "0.1" }
+percpu = { version = "0.2.0" }
+lazyinit = { version = "0.2" }
+axconfig = { workspace = true }
+axhal = { workspace = true, features = ["ipi"] }
diff --git a/modules/axipi/src/event.rs b/modules/axipi/src/event.rs
@@ -0,0 +1,57 @@
+use alloc::{boxed::Box, sync::Arc};
+
+/// A callback function that will be called when an [`IpiEvent`] is received and handled.
+pub struct Callback(Box<dyn FnOnce()>);
+
+impl Callback {
+    /// Create a new [`Callback`] with the given function.
+    pub fn new<F: FnOnce() + 'static>(callback: F) -> Self {
+        Self(Box::new(callback))
+    }
+
+    /// Call the callback function.
+    pub fn call(self) {
+        (self.0)()
+    }
+}
+
+impl<T: FnOnce() + 'static> From<T> for Callback {
+    fn from(callback: T) -> Self {
+        Self::new(callback)
+    }
+}
+
+/// A [`Callback`] that can be called multiple times. It's used for multicast IPI events.
+#[derive(Clone)]
+pub struct MulticastCallback(Arc<dyn Fn()>);
+
+impl MulticastCallback {
+    /// Create a new [`MulticastCallback`] with the given function.
+    pub fn new<F: Fn() + 'static>(callback: F) -> Self {
+        Self(Arc::new(callback))
+    }
+
+    /// Convert the [`MulticastCallback`] into a [`Callback`].
+    pub fn into_unicast(self) -> Callback {
+        Callback(Box::new(move || (self.0)()))
+    }
+
+    /// Call the callback function.
+    pub fn call(self) {
+        (self.0)()
+    }
+}
+
+impl<T: Fn() + 'static> From<T> for MulticastCallback {
+    fn from(callback: T) -> Self {
+        Self::new(callback)
+    }
+}
+
+/// An IPI event that is sent from a source CPU to the target CPU.
+pub struct IpiEvent {
+    /// The source CPU ID that sent the IPI event.
+    pub src_cpu_id: usize,
+    /// The callback function that will be called when the IPI event is handled.
+    pub callback: Callback,
+}
diff --git a/modules/axipi/src/lib.rs b/modules/axipi/src/lib.rs
@@ -0,0 +1,80 @@
+//! [ArceOS](https://github.com/arceos-org/arceos) Inter-Processor Interrupt (IPI) primitives.
+
+#![cfg_attr(not(test), no_std)]
+
+#[macro_use]
+extern crate log;
+extern crate alloc;
+
+use axhal::irq::{IPI_IRQ, IpiTarget};
+use axhal::percpu::this_cpu_id;
+use kspin::SpinNoIrq;
+use lazyinit::LazyInit;
+
+mod event;
+mod queue;
+
+pub use event::{Callback, MulticastCallback};
+use queue::IpiEventQueue;
+
+#[percpu::def_percpu]
+static IPI_EVENT_QUEUE: LazyInit<SpinNoIrq<IpiEventQueue>> = LazyInit::new();
+
+/// Initialize the per-CPU IPI event queue.
+pub fn init() {
+    IPI_EVENT_QUEUE.with_current(|ipi_queue| {
+        ipi_queue.init_once(SpinNoIrq::new(IpiEventQueue::default()));
+    });
+}
+
+/// Executes a callback on the specified destination CPU via IPI.
+pub fn run_on_cpu<T: Into<Callback>>(dest_cpu: usize, callback: T) {
+    info!("Send IPI event to CPU {}", dest_cpu);
+    if dest_cpu == this_cpu_id() {
+        // Execute callback on current CPU immediately
+        callback.into().call();
+    } else {
+        unsafe { IPI_EVENT_QUEUE.remote_ref_raw(dest_cpu) }
+            .lock()
+            .push(this_cpu_id(), callback.into());
+        axhal::irq::send_ipi(IPI_IRQ, IpiTarget::Other { cpu_id: dest_cpu });
+    }
+}
+
+/// Executes a callback on all other CPUs via IPI.
+pub fn run_on_each_cpu<T: Into<MulticastCallback>>(callback: T) {
+    info!("Send IPI event to all other CPUs");
+    let current_cpu_id = this_cpu_id();
+    let cpu_num = axconfig::plat::CPU_NUM;
+    let callback = callback.into();
+
+    // Execute callback on current CPU immediately
+    callback.clone().call();
+    // Push the callback to all other CPUs' IPI event queues
+    for cpu_id in 0..cpu_num {
+        if cpu_id != current_cpu_id {
+            unsafe { IPI_EVENT_QUEUE.remote_ref_raw(cpu_id) }
+                .lock()
+                .push(current_cpu_id, callback.clone().into_unicast());
+        }
+    }
+    // Send IPI to all other CPUs to trigger their callbacks
+    axhal::irq::send_ipi(
+        IPI_IRQ,
+        IpiTarget::AllExceptCurrent {
+            cpu_id: current_cpu_id,
+            cpu_num,
+        },
+    );
+}
+
+/// The handler for IPI events. It retrieves the events from the queue and calls the corresponding callbacks.
+pub fn ipi_handler() {
+    while let Some((src_cpu_id, callback)) = unsafe { IPI_EVENT_QUEUE.current_ref_mut_raw() }
+        .lock()
+        .pop_one()
+    {
+        debug!("Received IPI event from CPU {}", src_cpu_id);
+        callback.call();
+    }
+}
diff --git a/modules/axipi/src/queue.rs b/modules/axipi/src/queue.rs
@@ -0,0 +1,53 @@
+use alloc::collections::VecDeque;
+
+use crate::event::{Callback, IpiEvent};
+
+/// 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 {
+    events: VecDeque<IpiEvent>,
+}
+
+impl IpiEventQueue {
+    /// Create a new empty timer list.
+    pub fn new() -> Self {
+        Self {
+            events: VecDeque::new(),
+        }
+    }
+
+    /// Whether there is no event.
+    #[allow(dead_code)]
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.events.is_empty()
+    }
+
+    /// Push a new event into the queue.
+    pub fn push(&mut self, src_cpu_id: usize, callback: Callback) {
+        self.events.push_back(IpiEvent {
+            src_cpu_id,
+            callback,
+        });
+    }
+
+    /// Try to pop the latest event that exists in the queue.
+    ///
+    /// Return `None` if no event is available.
+    #[must_use]
+    pub fn pop_one(&mut self) -> Option<(usize, Callback)> {
+        if let Some(e) = self.events.pop_front() {
+            Some((e.src_cpu_id, e.callback))
+        } else {
+            None
+        }
+    }
+}
+
+impl Default for IpiEventQueue {
+    fn default() -> Self {
+        Self::new()
+    }
+}
diff --git a/modules/axruntime/Cargo.toml b/modules/axruntime/Cargo.toml
@@ -17,6 +17,7 @@ irq = ["axhal/irq", "axtask?/irq", "percpu"]
 tls = ["axhal/tls", "axtask?/tls"]
 alloc = ["axalloc"]
 paging = ["axhal/paging", "axmm"]
+ipi = ["dep:axipi"]
 
 multitask = ["axtask/multitask"]
 fs = ["axdriver", "axfs"]
@@ -35,7 +36,8 @@ axfs = { workspace = true, optional = true }
 axnet = { workspace = true, optional = true }
 axdisplay = { workspace = true, optional = true }
 axtask = { workspace = true, optional = true }
-axplat = "0.1"
+axipi = { workspace = true, optional = true }
+axplat = "0.2"
 
 crate_interface = "0.1"
 percpu = { version = "0.2", optional = true }
diff --git a/modules/axruntime/src/lib.rs b/modules/axruntime/src/lib.rs
diff --git a/modules/axruntime/src/mp.rs b/modules/axruntime/src/mp.rs
diff --git a/ulib/axstd/Cargo.toml b/ulib/axstd/Cargo.toml
