[wip] add ipi for x86_64

hky1999 · hky1999 · commit baac36ed1c31 · 2024-12-12T15:12:26.000+08:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/api/arceos_api/Cargo.toml b/api/arceos_api/Cargo.toml
@@ -43,3 +43,4 @@ axdriver = { workspace = true, optional = true }
 axfs = { workspace = true, optional = true }
 axnet = { workspace = true, optional = true }
 axdisplay = { workspace = true, optional = true }
+axipi = { workspace = true }
diff --git a/api/arceos_api/src/lib.rs b/api/arceos_api/src/lib.rs
@@ -391,6 +391,7 @@ pub mod modules {
     pub use axlog;
     pub use axruntime;
     pub use axsync;
+    pub use axipi;
 
     #[cfg(feature = "alloc")]
     pub use axalloc;
diff --git a/api/axfeat/Cargo.toml b/api/axfeat/Cargo.toml
@@ -20,7 +20,7 @@ fp_simd = ["axhal/fp_simd"]
 
 # Interrupts
 irq = ["axhal/irq", "axruntime/irq", "axtask?/irq"]
-ipi = ["axruntime/ipi"]
+ipi = ["axhal/ipi", "axruntime/ipi"]
 
 # Memory
 alloc = ["axalloc", "axruntime/alloc"]
@@ -58,7 +58,7 @@ driver-ixgbe = ["axdriver?/ixgbe"]
 driver-bcm2835-sdhci = ["axdriver?/bcm2835-sdhci"]
 
 #Hypervisor support 
-hv = ["axhal/hv"]
+hv = ["axhal/hv", "ipi"]
 
 # Logging
 log-level-off = ["axlog/log-level-off"]
diff --git a/modules/axhal/Cargo.toml b/modules/axhal/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 = ["dep:cpumask"]
+smp = []
 alloc = []
 fp_simd = []
 paging = ["axalloc", "page_table_multiarch"]
@@ -19,6 +19,7 @@ tls = ["alloc"]
 rtc = ["x86_rtc", "riscv_goldfish", "arm_pl031"]
 default = []
 hv = ["paging", "cortex-a", "percpu/arm-el2", "page_table_entry/arm-el2", "arm_gicv2/el2", "dep:crate_interface"]
+ipi = []
 
 [dependencies]
 log = "=0.4.21"
@@ -56,7 +57,7 @@ riscv_goldfish = { version = "0.1", optional = true }
 [target.'cfg(target_arch = "aarch64")'.dependencies]
 aarch64-cpu = "9.4"
 tock-registers = "0.8"
-arm_gicv2 = { git = "https://github.com/arceos-hypervisor/arm_gicv2" }
+arm_gicv2 = { git = "https://github.com/arceos-hypervisor/arm_gicv2", branch = "sgi" }
 crate_interface = { version = "0.1.3", optional = true }
 arm_pl011 = "0.1"
 arm_pl031 = { version = "0.2", optional = true }
diff --git a/modules/axhal/src/irq.rs b/modules/axhal/src/irq.rs
@@ -5,7 +5,10 @@ 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, IPI_IRQ_NUM};
+pub use crate::platform::irq::{register_handler, set_enable};
+
+#[cfg(feature = "ipi")]
+pub use crate::platform::irq::{send_sgi_all, send_sgi_one, IPI_IRQ_NUM};
 
 #[cfg(target_arch = "aarch64")]
 pub use crate::platform::irq::fetch_irq;
diff --git a/modules/axhal/src/platform/aarch64_common/gic.rs b/modules/axhal/src/platform/aarch64_common/gic.rs
@@ -40,14 +40,18 @@ pub fn set_enable(irq_num: usize, enabled: bool) {
 /// It also enables the IRQ if the registration succeeds. It returns `false` if
 /// the registration failed.
 pub fn register_handler(irq_num: usize, handler: IrqHandler) -> bool {
-    trace!("register handler irq {}", irq_num);
+    warn!("register handler irq {}", irq_num);
     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);
+/// Sends Software Generated Interrupt (SGI)(s) (usually IPI) to the given dest CPU.
+pub fn send_sgi_one(dest_cpu_id: usize, irq_num: usize) {
+    GICD.lock().send_sgi(dest_cpu_id, irq_num);
+}
+
+/// Sends a broadcast IPI to all CPUs.
+pub fn send_sgi_all(irq_num: usize) {
+    GICD.lock().send_sgi_all_except_self(irq_num);
 }
 
 /// Fetches the IRQ number.
diff --git a/modules/axhal/src/platform/mod.rs b/modules/axhal/src/platform/mod.rs
@@ -26,9 +26,9 @@ cfg_if::cfg_if! {
         mod aarch64_rk3588j;
         pub use self::aarch64_rk3588j::*;
     } else {
-        // mod dummy;
-        // pub use self::dummy::*;
-        mod aarch64_qemu_virt;
-        pub use self::aarch64_qemu_virt::*;
+        mod dummy;
+        pub use self::dummy::*;
+        // mod aarch64_qemu_virt;
+        // pub use self::aarch64_qemu_virt::*;
     }
 }
diff --git a/modules/axhal/src/platform/x86_pc/apic.rs b/modules/axhal/src/platform/x86_pc/apic.rs
@@ -14,6 +14,7 @@ pub(super) mod vectors {
     pub const APIC_TIMER_VECTOR: u8 = 0xf0;
     pub const APIC_SPURIOUS_VECTOR: u8 = 0xf1;
     pub const APIC_ERROR_VECTOR: u8 = 0xf2;
+    pub const APIC_IPI_VECTOR: u8 = 0xf2;
 }
 
 /// The maximum number of IRQs.
@@ -22,6 +23,9 @@ pub const MAX_IRQ_COUNT: usize = 256;
 /// The timer IRQ number.
 pub const TIMER_IRQ_NUM: usize = APIC_TIMER_VECTOR as usize;
 
+/// The IPI IRQ number.
+pub const IPI_IRQ_NUM: usize = APIC_IPI_VECTOR as usize;
+
 const IO_APIC_BASE: PhysAddr = pa!(0xFEC0_0000);
 
 static mut LOCAL_APIC: Option<LocalApic> = None;
@@ -52,6 +56,21 @@ pub fn register_handler(vector: usize, handler: crate::irq::IrqHandler) -> bool
     crate::irq::register_handler_common(vector, handler)
 }
 
+/// Sends Software Generated Interrupt (SGI)(s) (usually IPI) to the given dest CPU.
+pub fn send_sgi_one(dest_cpu_id: usize, irq_num: usize) {
+    unsafe {
+        local_apic().send_ipi(irq_num as _, dest_cpu_id as _);
+    };
+}
+
+/// Sends a broadcast IPI to all CPUs.
+pub fn send_sgi_all(irq_num: usize) {
+    use x2apic::lapic::IpiAllShorthand;
+    unsafe {
+        local_apic().send_ipi_all(irq_num as _, IpiAllShorthand::AllExcludingSelf);
+    };
+}
+
 /// Dispatches the IRQ.
 ///
 /// This function is called by the common interrupt handler. It looks
diff --git a/modules/axipi/Cargo.toml b/modules/axipi/Cargo.toml
@@ -20,3 +20,4 @@ percpu = { version = "0.1.5" }
 kspin = { version = "0.1" }
 
 axhal = { workspace = true }
+axconfig = { workspace = true }
diff --git a/modules/axipi/src/lib.rs b/modules/axipi/src/lib.rs
@@ -1,3 +1,9 @@
+//! [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 lazyinit::LazyInit;
@@ -11,29 +17,47 @@ mod queue;
 
 use queue::IPIEventQueue;
 
-pub use queue::IPIEventFn;
+pub use queue::{IPIEvent, IPIEventFn};
 
 #[percpu::def_percpu]
-static IPI_MSG_QUEUE: LazyInit<SpinNoIrq<IPIEventQueue<IPIEventFn>>> = LazyInit::new();
+static IPI_EVENT_QUEUE: LazyInit<SpinNoIrq<IPIEventQueue<IPIEventFn>>> = LazyInit::new();
 
+/// Initialize the per-CPU IPI event queue.
 pub fn init() {
-    IPI_MSG_QUEUE.with_current(|ipi_queue| {
+    IPI_EVENT_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) }
+/// Sends an IPI event to the processor(s) specified by `dest_cpu`.
+pub fn send_ipi_event_to_one(dest_cpu: usize, event: IPIEventFn) {
+    warn!("Send IPI event to CPU {}", dest_cpu);
+
+    unsafe { IPI_EVENT_QUEUE.remote_ref_raw(dest_cpu) }
         .lock()
         .push(this_cpu_id(), event);
+    axhal::irq::send_sgi_one(dest_cpu, IPI_IRQ_NUM);
+}
+
+/// Sends an IPI event to all processors except the current one.
+pub fn send_ipi_event_to_all(event: IPIEventFn) {
+    let current_cpu_id = this_cpu_id();
+    for cpu_id in 0..axconfig::SMP {
+        if cpu_id != current_cpu_id {
+            unsafe { IPI_EVENT_QUEUE.remote_ref_raw(cpu_id) }
+                .lock()
+                .push(current_cpu_id, event.clone());
+        }
+    }
+    axhal::irq::send_sgi_all(IPI_IRQ_NUM);
 }
 
-fn ipi_handler() {
-    while let Some(event) = unsafe { IPI_MSG_QUEUE.current_ref_mut_raw() }
+pub fn ipi_handler() {
+    while let Some((src_cpu_id, event)) = unsafe { IPI_EVENT_QUEUE.current_ref_mut_raw() }
         .lock()
         .pop_one()
     {
-        event();
+        warn!("Received IPI event from CPU {}", src_cpu_id);
+        event.callback();
     }
 }
diff --git a/modules/axipi/src/queue.rs b/modules/axipi/src/queue.rs
@@ -1,3 +1,4 @@
+use alloc::boxed::Box;
 use alloc::collections::VecDeque;
 
 /// A queue of IPI events.
@@ -15,7 +16,7 @@ pub trait IPIEvent: 'static {
 }
 
 struct IPIEventWrapper<E> {
-    src_cpu_id: u32,
+    src_cpu_id: usize,
     event: E,
 }
 
@@ -33,16 +34,16 @@ impl<E: IPIEvent> IPIEventQueue<E> {
         self.events.is_empty()
     }
 
-    pub fn push(&mut self, src_cpu_id: u32, event: E) {
+    pub fn push(&mut self, src_cpu_id: usize, 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> {
+    pub fn pop_one(&mut self) -> Option<(usize, E)> {
         if let Some(e) = self.events.pop_front() {
-            Some(e.event)
+            Some((e.src_cpu_id, e.event))
         } else {
             None
         }
@@ -58,13 +59,14 @@ impl<E: IPIEvent> Default for IPIEventQueue<E> {
 /// 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>);
+#[derive(Clone)]
+pub struct IPIEventFn(Box<&'static dyn Fn()>);
 
 impl IPIEventFn {
     /// Constructs a new [`IPIEventFn`] from a closure.
-    pub fn new<F>(f: F) -> Self
+    pub fn new<F>(f: &'static F) -> Self
     where
-        F: FnOnce() + 'static,
+        F: Fn(),
     {
         Self(Box::new(f))
     }
diff --git a/modules/axruntime/src/lib.rs b/modules/axruntime/src/lib.rs
@@ -259,7 +259,10 @@ fn init_interrupt() {
     });
 
     #[cfg(feature = "ipi")]
-    axipi::init();
+    {
+        axipi::init();
+        axhal::irq::register_handler(axhal::irq::IPI_IRQ_NUM, axipi::ipi_handler);
+    }
 
     // Enable IRQs before starting app
     axhal::arch::enable_irqs();
diff --git a/modules/axruntime/src/mp.rs b/modules/axruntime/src/mp.rs
@@ -43,6 +43,9 @@ pub extern "C" fn rust_main_secondary(cpu_id: usize) -> ! {
     #[cfg(feature = "multitask")]
     axtask::init_scheduler_secondary();
 
+    #[cfg(feature = "ipi")]
+    axipi::init();
+
     info!("Secondary CPU {:x} init OK.", cpu_id);
     super::INITED_CPUS.fetch_add(1, Ordering::Relaxed);
 
diff --git a/modules/axtask/src/run_queue.rs b/modules/axtask/src/run_queue.rs
@@ -450,6 +450,7 @@ impl AxRunQueue {
         // put it back to the run queue (except idle task).
         if task.transition_state(current_state, TaskState::Ready) && !task.is_idle() {
             // TODO: priority
+            #[cfg(feature = "smp")]
             task.set_cpu_id(self.cpu_id as _);
             self.scheduler.lock().put_prev_task(task, preempt);
             true
diff --git a/modules/axtask/src/task.rs b/modules/axtask/src/task.rs
@@ -1,13 +1,16 @@
 use alloc::{boxed::Box, string::String, sync::Arc};
 use core::ops::Deref;
-use core::sync::atomic::{AtomicBool, AtomicI32, AtomicU32, AtomicU64, AtomicU8, Ordering};
+use core::sync::atomic::{AtomicBool, AtomicI32, AtomicU64, AtomicU8, Ordering};
 use core::{alloc::Layout, cell::UnsafeCell, fmt, ptr::NonNull};
 
 #[cfg(feature = "smp")]
 use alloc::sync::Weak;
 #[cfg(feature = "preempt")]
 use core::sync::atomic::AtomicUsize;
 
+#[cfg(feature = "smp")]
+use core::sync::atomic::AtomicU32;
+
 use kspin::SpinNoIrq;
 use memory_addr::{align_up_4k, VirtAddr};
 
diff --git a/ulib/axstd/Cargo.toml b/ulib/axstd/Cargo.toml
@@ -65,7 +65,7 @@ driver-ixgbe = ["axfeat/driver-ixgbe"]
 driver-bcm2835-sdhci = ["axfeat/driver-bcm2835-sdhci"]
 
 # Hypervisor support
-hv = ["axfeat/hv"]
+hv = ["axfeat/hv", "axfeat/ipi"]
 
 # Logging
 log-level-off = ["axfeat/log-level-off"]

Original file line number	Diff line number	Diff line change
`@@ -26,9 +26,9 @@ cfg_if::cfg_if! {`
`26`	`26`	`mod aarch64_rk3588j;`
`27`	`27`	`pub use self::aarch64_rk3588j::*;`
`28`	`28`	`} else {`
`29`		`- // mod dummy;`
`30`		`- // pub use self::dummy::*;`
`31`		`- mod aarch64_qemu_virt;`
`32`		`- pub use self::aarch64_qemu_virt::*;`
	`29`	`+ mod dummy;`
	`30`	`+ pub use self::dummy::*;`
	`31`	`+ // mod aarch64_qemu_virt;`
	`32`	`+ // pub use self::aarch64_qemu_virt::*;`
`33`	`33`	`}`
`34`	`34`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,3 +20,4 @@ percpu = { version = "0.1.5" }`
`20`	`20`	`kspin = { version = "0.1" }`
`21`	`21`
`22`	`22`	`axhal = { workspace = true }`
	`23`	`+axconfig = { workspace = true }`