更新依赖项并移除不必要的异常处理代码

Author: ZR233

Cargo.toml

@@ -26,6 +26,7 @@ tock-registers = "0.9"
 
 axerrno = "0.1.0"
 percpu = {version = "0.2.0", features = ["arm-el2"]}
+axcpu = {path="../axcpu", features = ["arm-el2"]}
 
 axaddrspace = {git = "https://github.com/arceos-hypervisor/axaddrspace.git"}
 axdevice_base = {git = "https://github.com/arceos-hypervisor/axdevice_crates.git"}

src/exception.S

@@ -28,11 +28,6 @@ pub enum TrapKind {
 }
 }
 
-/// Equals to [`TrapKind::Synchronous`], used in exception.S.
-const EXCEPTION_SYNC: usize = TrapKind::Synchronous as usize;
-/// Equals to [`TrapKind::Irq`], used in exception.S.
-const EXCEPTION_IRQ: usize = TrapKind::Irq as usize;
-
 #[repr(u8)]
 #[derive(Debug)]
 #[allow(unused)]
@@ -43,12 +38,6 @@ enum TrapSource {
     LowerAArch32 = 3,
 }
 
-core::arch::global_asm!(
-    include_str!("exception.S"),
-    exception_sync = const EXCEPTION_SYNC,
-    exception_irq = const EXCEPTION_IRQ,
-);
-
 /// Handles synchronous exceptions that occur during the execution of a guest VM.
 ///
 /// This function examines the exception class (EC) to determine the cause of the exception
@@ -276,33 +265,6 @@ fn handle_smc64_exception(ctx: &mut TrapFrame) -> AxResult<AxVCpuExitReason> {
     }
 }
 
-/// Handles IRQ exceptions that occur from the current exception level.
-/// Dispatches IRQs to the appropriate handler provided by the underlying host OS,
-/// which is registered at [`crate::pcpu::IRQ_HANDLER`] during `Aarch64PerCpu::new()`.
-#[unsafe(no_mangle)]
-fn current_el_irq_handler(_tf: &mut TrapFrame) {
-    unsafe { crate::pcpu::IRQ_HANDLER.current_ref_raw() }
-        .get()
-        .unwrap()()
-}
-
-/// Handles synchronous exceptions that occur from the current exception level.
-#[unsafe(no_mangle)]
-fn current_el_sync_handler(tf: &mut TrapFrame) {
-    let esr = ESR_EL2.extract();
-    let ec = ESR_EL2.read(ESR_EL2::EC);
-    let iss = ESR_EL2.read(ESR_EL2::ISS);
-
-    error!("ESR_EL2: {:#x}", esr.get());
-    error!("Exception Class: {ec:#x}");
-    error!("Instruction Specific Syndrome: {iss:#x}");
-
-    panic!(
-        "Unhandled synchronous exception from current EL: {:#x?}",
-        tf
-    );
-}
-
 /// 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.
@@ -340,7 +302,7 @@ fn current_el_sync_handler(tf: &mut TrapFrame) {
 ///   invoked as part of the low-level hypervisor or VM exit handling routines.
 #[unsafe(naked)]
 #[unsafe(no_mangle)]
-unsafe extern "C" fn vmexit_trampoline() -> ! {
+unsafe extern "C" fn handle_vmexit() -> ! {
     core::arch::naked_asm!(
         // Curretly `sp` points to the base address of `Aarch64VCpu.ctx`, which stores guest's `TrapFrame`.
         "add x9, sp, 34 * 8", // Skip the exception frame.
@@ -351,12 +313,3 @@ unsafe extern "C" fn vmexit_trampoline() -> ! {
         "ret", // Control flow is handed back to Aarch64VCpu.run(), simulating the normal return of the `run_guest` function.
     )
 }
-
-/// Deal with invalid aarch64 exception.
-#[unsafe(no_mangle)]
-fn invalid_exception_el2(tf: &mut TrapFrame, kind: TrapKind, source: TrapSource) {
-    panic!(
-        "Invalid exception {:?} from {:?}:\n{:#x?}",
-        kind, source, tf
-    );
-}

src/exception.rs

@@ -1,4 +1,4 @@
-use core::{cell::OnceCell, marker::PhantomData};
+use core::marker::PhantomData;
 
 use aarch64_cpu::registers::*;
 use axerrno::AxResult;
@@ -14,27 +14,8 @@ pub struct Aarch64PerCpu<H: AxVCpuHal> {
     _phantom: PhantomData<H>,
 }
 
-#[percpu::def_percpu]
-static ORI_EXCEPTION_VECTOR_BASE: usize = 0;
-
-/// IRQ handler registered by underlying host OS during per-cpu initialization,
-/// for dispatching IRQs to the host OS.
-///
-/// Set `IRQ_HANDLER` as per-cpu variable to avoid the need of `OnceLock`.
-#[percpu::def_percpu]
-pub static IRQ_HANDLER: OnceCell<&(dyn Fn() + Send + Sync)> = OnceCell::new();
-
-unsafe extern "C" {
-    fn exception_vector_base_vcpu();
-}
-
 impl<H: AxVCpuHal> AxArchPerCpu for Aarch64PerCpu<H> {
     fn new(cpu_id: usize) -> AxResult<Self> {
-        // Register IRQ handler for this CPU.
-        let _ = unsafe { IRQ_HANDLER.current_ref_mut_raw() }
-            .set(&|| H::irq_hanlder())
-            .map(|_| {});
-
         Ok(Self {
             cpu_id,
             _phantom: PhantomData,
@@ -49,11 +30,11 @@ impl<H: AxVCpuHal> AxArchPerCpu for Aarch64PerCpu<H> {
         // First we save origin `exception_vector_base`.
         // Safety:
         // Todo: take care of `preemption`
-        unsafe { ORI_EXCEPTION_VECTOR_BASE.write_current_raw(VBAR_EL2.get() as usize) }
+        // unsafe { ORI_EXCEPTION_VECTOR_BASE.write_current_raw(VBAR_EL2.get() as usize) }
 
         // Set current `VBAR_EL2` to `exception_vector_base_vcpu`
         // defined in this crate.
-        VBAR_EL2.set(exception_vector_base_vcpu as usize as _);
+        // VBAR_EL2.set(exception_vector_base_vcpu as usize as _);
 
         HCR_EL2.modify(
             HCR_EL2::VM::Enable
@@ -83,7 +64,7 @@ impl<H: AxVCpuHal> AxArchPerCpu for Aarch64PerCpu<H> {
         // Reset `VBAR_EL2` into previous value.
         // Safety:
         // Todo: take care of `preemption`
-        VBAR_EL2.set(unsafe { ORI_EXCEPTION_VECTOR_BASE.read_current_raw() } as _);
+        // VBAR_EL2.set(unsafe { ORI_EXCEPTION_VECTOR_BASE.read_current_raw() } as _);
 
         HCR_EL2.set(HCR_EL2::VM::Disable.into());
         Ok(())

src/pcpu.rs

@@ -232,6 +232,37 @@ impl<H: AxVCpuHal> Aarch64VCpu<H> {
 
 /// Private functions related to vcpu runtime control flow.
 impl<H: AxVCpuHal> Aarch64VCpu<H> {
+    // /// Save host context and run guest.
+    // ///
+    // /// When a VM-Exit happens when guest's vCpu is running,
+    // /// the control flow will be redirected to this function through `return_run_guest`.
+    // #[unsafe(naked)]
+    // unsafe extern "C" fn run_guest(&mut self) -> usize {
+    //     // Fixes: https://github.com/arceos-hypervisor/arm_vcpu/issues/22
+    //     //
+    //     // The original issue seems to be caused by an unexpected compiler optimization that takes
+    //     // the dummy return value `0` of `run_guest` as the actual return value. By replacing the
+    //     // original `run_guest` with the current naked one, we eliminate the dummy code path of the
+    //     // original version, and ensure that the compiler does not perform any unexpected return
+    //     // value optimization.
+    //     core::arch::naked_asm!(
+    //         // Save host context.
+    //         save_regs_to_stack!(),
+    //         // Save current host stack top to `self.host_stack_top`.
+    //         //
+    //         // 'extern "C"' here specifies the aapcs64 calling convention, according to which
+    //         // the first and only parameter, the pointer of self, should be in x0:
+    //         "mov x9, sp",
+    //         "add x0, x0, {host_stack_top_offset}",
+    //         "str x9, [x0]",
+    //         // Go to `context_vm_entry`.
+    //         "b context_vm_entry",
+    //         // Panic if the control flow comes back here, which should never happen.
+    //         "b {run_guest_panic}",
+    //         host_stack_top_offset = const core::mem::size_of::<TrapFrame>(),
+    //         run_guest_panic = sym Self::run_guest_panic,
+    //     );
+    // }
     /// Save host context and run guest.
     ///
     /// When a VM-Exit happens when guest's vCpu is running,
@@ -256,14 +287,13 @@ impl<H: AxVCpuHal> Aarch64VCpu<H> {
             "add x0, x0, {host_stack_top_offset}",
             "str x9, [x0]",
             // Go to `context_vm_entry`.
-            "b context_vm_entry",
-            // Panic if the control flow comes back here, which should never happen.
+            "b {entry}",
             "b {run_guest_panic}",
             host_stack_top_offset = const core::mem::size_of::<TrapFrame>(),
+            entry = sym axcpu::el2::enter_guest,
             run_guest_panic = sym Self::run_guest_panic,
         );
     }
-
     /// This function is called when the control flow comes back to `run_guest`. To provide a error
     /// message for debugging purposes.
     ///
@@ -325,9 +355,7 @@ impl<H: AxVCpuHal> Aarch64VCpu<H> {
 
         let result = match exit_reason {
             TrapKind::Synchronous => handle_exception_sync(&mut self.ctx),
-            TrapKind::Irq => Ok(AxVCpuExitReason::ExternalInterrupt {
-                vector: H::irq_fetch() as _,
-            }),
+            TrapKind::Irq => Ok(AxVCpuExitReason::ExternalInterrupt { vector: 0 }),
             _ => panic!("Unhandled exception {:?}", exit_reason),
         };