[wip] seperate return_run_guest and dispatch_irq

Author: hky1999

Cargo.toml

@@ -6,14 +6,14 @@ edition = "2021"
 [dependencies]
 log = "0.4.21"
 
-cortex-a = "8.1.1"
 aarch64-cpu = "9.3"
 smccc = "0.1.1"
 tock-registers = "0.8"
 numeric-enum-macro = "0.2"
 
 axerrno = "0.1.0"
 percpu = "0.1.4"
+crate_interface = "0.1"
 
 axaddrspace = { git = "https://github.com/arceos-hypervisor/axaddrspace.git" }
 axvcpu = { git = "https://github.com/arceos-hypervisor/axvcpu.git" }

src/exception.rs

@@ -235,7 +235,42 @@ fn handle_psci_call(ctx: &mut TrapFrame) -> Option<AxResult<AxVCpuExitReason>> {
     })
 }
 
-/// A trampoline function for sp switching during handling VM exits.
+/// Dispatches IRQs to the appropriate handler provided by the underlying host OS.
+fn dispatch_irq() {
+    crate_interface::call_interface!(crate::HalIf::irq_hanlder())
+}
+
+/// A trampoline function for handling exceptions (VM exits) in EL2.
+///
+/// Functionality:
+///
+/// 1. **Check if VCPU is running:**
+///    - The `vcpu_running` function is called to check if the VCPU is currently running.
+///     If the VCPU is running, the control flow is transferred to the `return_run_guest` function.
+///
+/// 2. **Dispatch IRQ:**
+///   - If there is no active vcpu running, the `dispatch_irq` function is called to handle the IRQ,
+///     which will dispatch this irq routine to the underlining host OS.
+///
+#[naked]
+#[no_mangle]
+unsafe extern "C" fn vmexit_trampoline() {
+    core::arch::asm!(
+        "bl {vcpu_running}", // Check if vcpu is running.
+        "cbnz x0, {return_run_guest}", // If vcpu_running returns true, jump to `return_run_guest`.
+        "bl {dispatch_irq}",
+        "ret", // Control flow is handed back to Aarch64VCpu.run(), simulating the normal return of the `run_guest` function.
+        vcpu_running = sym crate::vcpu::vcpu_running,
+        return_run_guest = sym return_run_guest,
+        dispatch_irq = sym dispatch_irq,
+        options(noreturn),
+    )
+}
+
+/// A trampoline function for sp switching during handling VM exits,
+/// when **there is a active VCPU running**, which means that the host context is stored
+/// into host stack in `run_guest` function.
+///
 /// # Functionality
 ///
 /// 1. **Restore Previous Host Stack pointor:**
@@ -269,8 +304,7 @@ fn handle_psci_call(ctx: &mut TrapFrame) -> Option<AxResult<AxVCpuExitReason>> {
 ///   invoked as part of the low-level hypervisor or VM exit handling routines.
 #[naked]
 #[no_mangle]
-unsafe extern "C" fn vmexit_trampoline() {
-    // Note: Currently `sp` points to `&Aarch64VCpu.ctx`, which is just the base address of Aarch64VCpu struct.
+unsafe extern "C" fn return_run_guest() {
     core::arch::asm!(
         "add sp, sp, 34 * 8",       // Skip the exception frame.
         "mov x9, sp", // Currently `sp` points to `&Aarch64VCpu.host_stack_top`, see `run_guest()` in vcpu.rs.

src/exception_utils.rs

@@ -272,7 +272,7 @@ macro_rules! save_regs_to_stack {
 ///
 /// ## Note
 ///
-/// This macro is called in `vmexit_trampoline()` in exception.rs,
+/// This macro is called in `return_run_guest()` in exception.rs,
 /// it should only be used after `save_regs_to_stack!` to correctly restore the control flow of `Aarch64VCpu.run()`.
 macro_rules! restore_regs_from_stack {
     () => {

src/lib.rs

@@ -30,3 +30,9 @@ pub fn has_hardware_support() -> bool {
     // Current just return true by default.
     true
 }
+
+/// Low-level resource interfaces that must be implemented by the crate user.
+#[crate_interface::def_interface]
+pub trait HalIf {
+    fn irq_hanlder();
+}

src/vcpu.rs

@@ -19,6 +19,9 @@ core::arch::global_asm!(include_str!("entry.S"));
 #[percpu::def_percpu]
 static HOST_SP_EL0: u64 = 0;
 
+#[percpu::def_percpu]
+static VCPU_RUNNING: bool = false;
+
 /// Save host's `SP_EL0` to the current percpu region.
 unsafe fn save_host_sp_el0() {
     HOST_SP_EL0.write_current_raw(SP_EL0.get())
@@ -29,6 +32,21 @@ unsafe fn restore_host_sp_el0() {
     SP_EL0.set(HOST_SP_EL0.read_current_raw());
 }
 
+#[no_mangle]
+unsafe fn set_vcpu_running() {
+    VCPU_RUNNING.write_current_raw(true);
+}
+
+#[no_mangle]
+pub(crate) unsafe fn clear_vcpu_running() {
+    VCPU_RUNNING.write_current_raw(false);
+}
+
+#[no_mangle]
+pub(crate) unsafe fn vcpu_running() -> bool {
+    VCPU_RUNNING.read_current_raw()
+}
+
 /// (v)CPU register state that must be saved or restored when entering/exiting a VM or switching
 /// between VMs.
 #[repr(C)]
@@ -104,6 +122,9 @@ impl<H: AxVCpuHal> axvcpu::AxArchVCpu for Aarch64VCpu<H> {
             self.restore_vm_system_regs();
             self.run_guest()
         };
+        unsafe {
+            clear_vcpu_running();
+        }
 
         let trap_kind = TrapKind::try_from(exit_reson as u8).expect("Invalid TrapKind");
         self.vmexit_handler(trap_kind)
@@ -128,18 +149,25 @@ impl<H: AxVCpuHal> Aarch64VCpu<H> {
     unsafe fn run_guest(&mut self) -> usize {
         // Save function call context.
         core::arch::asm!(
-            save_regs_to_stack!(),  // Save host context.
+            // Save host context.
+            save_regs_to_stack!(),
             "mov x9, sp",
             "mov x10, x11",
-            "str x9, [x10]",    // Save current host stack top in the `Aarch64VCpu` struct.
+            // Save current host stack top in the `Aarch64VCpu` struct.
+            "str x9, [x10]",
             "mov x0, x11",
+            // Since now the host context is saved into host stack,
+            // mark `VCPU_RUNNING` as true,
+            // so that a exception's control flow can be redirected to the `return_run_guest`.
+            "bl {set_vcpu_running}",
             "b context_vm_entry",
+            set_vcpu_running = sym set_vcpu_running,
             // in(reg) here is dangerous, because the compiler may use the register we want to use, creating a conflict.
             in("x11") &self.host_stack_top as *const _ as usize,
             options(nostack)
         );
 
-        // the dummy return value, the real return value is in x0 when `vmexit_trampoline` returns
+        // the dummy return value, the real return value is in x0 when `return_run_guest` returns
         0
     }