Refactor VMX module to use unified Result type and improve error handling

- Replaced AxResult with a custom Result type across the VMX module for consistency.
- Updated function signatures in structs and implementations to reflect the new Result type.
- Enhanced error handling by using VmxError for specific error cases.
- Adjusted VM exit reason handling to use VmxRawExitReason instead of VmxExitReason.
- Improved debug formatting in VmxVcpu to handle potential read errors gracefully.
- Cleaned up unnecessary imports and comments for better code clarity.

Author: ZR233

Cargo.toml

@@ -23,13 +23,14 @@ x86_64 = "0.15"
 raw-cpuid = "11.0"
 numeric-enum-macro = "0.2"
 
-axerrno = "0.1.0"
+# axerrno = "0.1.0"  # 移除，改用 thiserror
+thiserror = {version = "2.0", default-features = false}
 page_table_entry = "0.5"
 memory_addr = "0.4"
-crate_interface = "0.1"
+# crate_interface = "0.1"
 
-# axaddrspace = "0.2.0"
-axvcpu = "0.1.0"
+axaddrspace = "0.2.0"
+# axvcpu = "0.1.0"  # 移除 axvcpu 依赖，使用自己的 Hal trait
 x86_vlapic = "0.1.0"
 axdevice_base = "0.1.0"
 

src/lib.rs

@@ -7,6 +7,9 @@
 extern crate log;
 
 extern crate alloc;
+use alloc::string::String;
+
+use thiserror::Error;
 
 #[cfg(test)]
 mod test_utils;
@@ -21,7 +24,7 @@ cfg_if::cfg_if! {
     if #[cfg(feature = "vmx")] {
         mod vmx;
         use vmx as vender;
-        pub use vmx::{VmxExitInfo, VmxExitReason, VmxInterruptInfo, VmxIoExitInfo};
+        pub use vmx::{VmxExitInfo, VmxRawExitReason, VmxInterruptInfo, VmxIoExitInfo};
 
         pub use vender::VmxArchVCpu;
         pub use vender::VmxArchPerCpuState;
@@ -35,6 +38,69 @@ pub use vender::has_hardware_support;
 pub type HostVirtAddr = usize;
 pub type HostPhysAddr = usize;
 
+/// x86 VCPU 错误类型
+#[derive(Error, Debug)]
+pub enum VmxError {
+    /// VMX 指令错误
+    #[error("VMX instruction error: {0}")]
+    VmxInstructionError(String),
+
+    /// VMCS 指针无效
+    #[error("VMCS pointer is not valid")]
+    InvalidVmcsPtr,
+
+    /// VMX 未被启用
+    #[error("VMX is not enabled")]
+    VmxNotEnabled,
+
+    /// VMX 已被启用
+    #[error("VMX is already enabled")]
+    VmxAlreadyEnabled,
+
+    /// 内存分配失败
+    #[error("memory allocation failed")]
+    MemoryAllocationFailed,
+
+    /// 无效的物理地址
+    #[error("invalid physical address: {0:#x}")]
+    InvalidPhysAddr(usize),
+
+    /// 无效的虚拟地址
+    #[error("invalid virtual address: {0:#x}")]
+    InvalidVirtAddr(usize),
+
+    /// 无效的 VMCS 配置
+    #[error("invalid VMCS configuration: {0}")]
+    InvalidVmcsConfig(String),
+
+    /// EPT 违规
+    #[error("EPT violation at GPA {0:#x}, error code {1:#x}")]
+    EptViolation(usize, u64),
+
+    /// IO 指令错误
+    #[error("IO instruction error: port={0:#x}, width={1}")]
+    IoError(u16, u8),
+
+    /// MSR 访问错误
+    #[error("MSR access error: {0:#x}")]
+    MsrError(u32),
+
+    /// VCpu 未绑定
+    #[error("VCpu is not bound to current CPU")]
+    VCPUNotBound,
+
+    /// 不支持的 VMX 功能
+    #[error("unsupported VMX feature: {0}")]
+    UnsupportedFeature(String),
+
+    /// 其他 VMX 错误
+    #[error("VMX error: {0}")]
+    Other(String),
+}
+
+/// x86 VCPU Result 类型
+pub type Result<T> = core::result::Result<T, VmxError>;
+
 /// Hardware abstraction layer for memory management.
 pub trait Hal {
     /// Allocates a frame and returns its host physical address. The
@@ -73,3 +139,37 @@ pub trait Hal {
     /// * `HostPhysAddr` - The corresponding physical address.
     fn virt_to_phys(vaddr: HostVirtAddr) -> HostPhysAddr;
 }
+
+// ==================== x86 特定的 VCPU 退出原因定义 ====================
+// 这些类型替代 axvcpu 中的定义，使 x86_vcpu 完全独立
+
+use axaddrspace::{
+    GuestPhysAddr,
+    device::{AccessWidth, Port, SysRegAddr},
+};
+
+/// x86 VCPU 退出原因
+#[derive(Debug)]
+pub enum VmxExitReason {
+    /// 超级调用
+    Hypercall { nr: usize, args: [usize; 8] },
+    /// IO 读
+    IoRead { port: Port, width: AccessWidth },
+    /// IO 写
+    IoWrite { port: Port, width: AccessWidth, data: u32 },
+    /// 系统寄存器读
+    SysRegRead { addr: SysRegAddr, reg: usize },
+    /// 系统寄存器写
+    SysRegWrite { addr: SysRegAddr, value: u64 },
+    /// 外部中断
+    ExternalInterrupt { vector: usize },
+    /// CPU 启动
+    CpuUp { target_cpu: usize, entry_point: GuestPhysAddr, arg: u64 },
+    /// CPU 关闭
+    CpuDown { state: usize },
+    /// 系统关闭
+    SystemDown,
+    /// 无操作
+    Nothing,
+}
+

src/mem.rs

@@ -1,6 +1,7 @@
 use core::marker::PhantomData;
 
-use crate::{Hal, HostPhysAddr};
+use memory_addr::PAGE_SIZE_4K as PAGE_SIZE;
+use crate::{Hal, HostPhysAddr, Result, VmxError};
 
 /// A physical frame which will be automatically deallocated when dropped.
 ///
@@ -14,18 +15,18 @@ pub struct PhysFrame<H: Hal> {
 
 impl<H: Hal> PhysFrame<H> {
     /// Allocate a [`PhysFrame`].
-    pub fn alloc() -> AxResult<Self> {
+    pub fn alloc() -> Result<Self> {
         let start_paddr = H::alloc_frame()
-            .ok_or_else(|| ax_err_type!(NoMemory, "allocate physical frame failed"))?;
-        assert_ne!(start_paddr.as_usize(), 0);
+            .ok_or_else(|| VmxError::MemoryAllocationFailed)?;
+        assert_ne!(start_paddr, 0);
         Ok(Self {
             start_paddr: Some(start_paddr),
             _marker: PhantomData,
         })
     }
 
     /// Allocate a [`PhysFrame`] and fill it with zeros.
-    pub fn alloc_zero() -> AxResult<Self> {
+    pub fn alloc_zero() -> Result<Self> {
         let mut f = Self::alloc()?;
         f.fill(0);
         Ok(f)
@@ -51,7 +52,7 @@ impl<H: Hal> PhysFrame<H> {
 
     /// Get a mutable pointer to the frame.
     pub fn as_mut_ptr(&self) -> *mut u8 {
-        H::phys_to_virt(self.start_paddr()).as_mut_ptr()
+        H::phys_to_virt(self.start_paddr()) as *mut u8
     }
 
     /// Fill the frame with a byte. Works only when the frame is 4 KiB in size.
@@ -60,7 +61,7 @@ impl<H: Hal> PhysFrame<H> {
     }
 }
 
-impl<H: AxMmHal> Drop for PhysFrame<H> {
+impl<H: Hal> Drop for PhysFrame<H> {
     fn drop(&mut self) {
         if let Some(start_paddr) = self.start_paddr {
             H::dealloc_frame(start_paddr);

src/vmx/definitions.rs

@@ -54,7 +54,7 @@ impl From<u32> for VmxInstructionError {
 }
 
 impl Debug for VmxInstructionError {
-    fn fmt(&self, f: &mut Formatter) -> Result {
+    fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
         write!(f, "VmxInstructionError({}, {:?})", self.0, self.as_str())
     }
 }
@@ -69,7 +69,7 @@ numeric_enum_macro::numeric_enum! {
 /// the execution of a virtual machine in VMX (Virtual Machine Extensions) mode.
 /// Each variant corresponds to a specific exit reason that can be identified
 /// and handled by the hypervisor.
-pub enum VmxExitReason {
+pub enum VmxRawExitReason {
     /// Exception or non-maskable interrupt (NMI) occurred.
     EXCEPTION_NMI = 0,
     /// An external interrupt was received.

src/vmx/mod.rs

@@ -6,13 +6,15 @@ mod vcpu;
 mod vmcs;
 
 use self::structs::VmxBasic;
-use axerrno::ax_err_type;
 
-pub use self::definitions::VmxExitReason;
+pub use self::definitions::VmxRawExitReason;
 pub use self::percpu::VmxPerCpuState as VmxArchPerCpuState;
 pub use self::vcpu::VmxVcpu as VmxArchVCpu;
 pub use self::vmcs::{VmxExitInfo, VmxInterruptInfo, VmxIoExitInfo};
 
+// 导出自定义错误类型
+pub use crate::{VmxError, Result};
+
 /// Return if current platform support virtualization extension.
 pub fn has_hardware_support() -> bool {
     if let Some(feature) = raw_cpuid::CpuId::new().get_feature_info() {
@@ -26,10 +28,12 @@ pub fn read_vmcs_revision_id() -> u32 {
     VmxBasic::read().revision_id
 }
 
-fn as_axerr(err: x86::vmx::VmFail) -> axerrno::AxError {
+fn as_axerr(err: x86::vmx::VmFail) -> VmxError {
     use x86::vmx::VmFail;
     match err {
-        VmFail::VmFailValid => ax_err_type!(BadState, vmcs::instruction_error().as_str()),
-        VmFail::VmFailInvalid => ax_err_type!(BadState, "VMCS pointer is not valid"),
+        VmFail::VmFailValid => {
+            VmxError::VmxInstructionError(alloc::string::String::from(vmcs::instruction_error().as_str()))
+        }
+        VmFail::VmFailInvalid => VmxError::InvalidVmcsPtr,
     }
 }

src/vmx/percpu.rs

@@ -1,10 +1,10 @@
 use x86::bits64::vmx;
 use x86_64::registers::control::{Cr0, Cr4, Cr4Flags};
 
-use axerrno::{AxResult, ax_err, ax_err_type};
-use axvcpu::{AxArchPerCpu, AxVCpuHal};
+use alloc::format;
 use memory_addr::PAGE_SIZE_4K as PAGE_SIZE;
 
+use crate::{Hal, Result, VmxError};
 use crate::msr::Msr;
 use crate::vmx::has_hardware_support;
 use crate::vmx::structs::{FeatureControl, FeatureControlFlags, VmxBasic, VmxRegion};
@@ -15,7 +15,7 @@ use crate::vmx::structs::{FeatureControl, FeatureControlFlags, VmxBasic, VmxRegi
 /// when operating in VMX mode, including the VMCS revision identifier and
 /// the VMX region.
 #[derive(Debug)]
-pub struct VmxPerCpuState<H: AxVCpuHal> {
+pub struct VmxPerCpuState<H: Hal> {
     /// The VMCS (Virtual Machine Control Structure) revision identifier.
     ///
     /// This identifier is used to ensure compatibility between the software
@@ -26,27 +26,27 @@ pub struct VmxPerCpuState<H: AxVCpuHal> {
     ///
     /// This region typically contains the VMCS and other state information
     /// required for managing virtual machines on this particular CPU.
-    vmx_region: VmxRegion<H::MmHal>,
+    vmx_region: VmxRegion<H>,
 }
 
-impl<H: AxVCpuHal> AxArchPerCpu for VmxPerCpuState<H> {
-    fn new(_cpu_id: usize) -> AxResult<Self> {
+impl<H: Hal> VmxPerCpuState<H> {
+    pub fn new(_cpu_id: usize) -> Result<Self> {
         Ok(Self {
             vmcs_revision_id: 0,
             vmx_region: unsafe { VmxRegion::uninit() },
         })
     }
 
-    fn is_enabled(&self) -> bool {
+    pub fn is_enabled(&self) -> bool {
         Cr4::read().contains(Cr4Flags::VIRTUAL_MACHINE_EXTENSIONS)
     }
 
-    fn hardware_enable(&mut self) -> AxResult {
+    pub fn hardware_enable(&mut self) -> Result<()> {
         if !has_hardware_support() {
-            return ax_err!(Unsupported, "CPU does not support feature VMX");
+            return Err(VmxError::UnsupportedFeature("CPU does not support feature VMX".into()));
         }
         if self.is_enabled() {
-            return ax_err!(ResourceBusy, "VMX is already turned on");
+            return Err(VmxError::VmxAlreadyEnabled);
         }
 
         // Enable XSAVE/XRSTOR.
@@ -61,7 +61,7 @@ impl<H: AxVCpuHal> AxArchPerCpu for VmxPerCpuState<H> {
                 ctrl | FeatureControlFlags::LOCKED | FeatureControlFlags::VMXON_ENABLED_OUTSIDE_SMX,
             )
         } else if !vmxon_outside {
-            return ax_err!(Unsupported, "VMX disabled by BIOS");
+            return Err(VmxError::UnsupportedFeature("VMX disabled by BIOS".into()));
         }
 
         // Check control registers are in a VMX-friendly state. (SDM Vol. 3C, Appendix A.7, A.8)
@@ -77,28 +77,28 @@ impl<H: AxVCpuHal> AxArchPerCpu for VmxPerCpuState<H> {
             }};
         }
         if !cr_is_valid!(Cr0::read().bits(), CR0) {
-            return ax_err!(BadState, "host CR0 is not valid in VMX operation");
+            return Err(VmxError::InvalidVmcsConfig("host CR0 is not valid in VMX operation".into()));
         }
         if !cr_is_valid!(Cr4::read().bits(), CR4) {
-            return ax_err!(BadState, "host CR4 is not valid in VMX operation");
+            return Err(VmxError::InvalidVmcsConfig("host CR4 is not valid in VMX operation".into()));
         }
 
         // Get VMCS revision identifier in IA32_VMX_BASIC MSR.
         let vmx_basic = VmxBasic::read();
         if vmx_basic.region_size as usize != PAGE_SIZE {
-            return ax_err!(Unsupported);
+            return Err(VmxError::UnsupportedFeature("VMX region size is not 4K".into()));
         }
         if vmx_basic.mem_type != VmxBasic::VMX_MEMORY_TYPE_WRITE_BACK {
-            return ax_err!(Unsupported);
+            return Err(VmxError::UnsupportedFeature("VMX memory type is not write-back".into()));
         }
         if vmx_basic.is_32bit_address {
-            return ax_err!(Unsupported);
+            return Err(VmxError::UnsupportedFeature("32-bit VMX not supported".into()));
         }
         if !vmx_basic.io_exit_info {
-            return ax_err!(Unsupported);
+            return Err(VmxError::UnsupportedFeature("IO exit info not supported".into()));
         }
         if !vmx_basic.vmx_flex_controls {
-            return ax_err!(Unsupported);
+            return Err(VmxError::UnsupportedFeature("VMX flex controls not supported".into()));
         }
         self.vmcs_revision_id = vmx_basic.revision_id;
         self.vmx_region = VmxRegion::new(self.vmcs_revision_id, false)?;
@@ -107,30 +107,24 @@ impl<H: AxVCpuHal> AxArchPerCpu for VmxPerCpuState<H> {
             // Enable VMX using the VMXE bit.
             Cr4::write(Cr4::read() | Cr4Flags::VIRTUAL_MACHINE_EXTENSIONS);
             // Execute VMXON.
-            vmx::vmxon(self.vmx_region.phys_addr().as_usize() as _).map_err(|err| {
-                ax_err_type!(
-                    BadState,
-                    format_args!("VMX instruction vmxon failed: {:?}", err)
-                )
+            vmx::vmxon(self.vmx_region.phys_addr() as _).map_err(|err| {
+                VmxError::VmxInstructionError(format!("VMX instruction vmxon failed: {:?}", err))
             })?;
         }
         info!("[AxVM] succeeded to turn on VMX.");
 
         Ok(())
     }
 
-    fn hardware_disable(&mut self) -> AxResult {
+    pub fn hardware_disable(&mut self) -> Result<()> {
         if !self.is_enabled() {
-            return ax_err!(BadState, "VMX is not enabled");
+            return Err(VmxError::VmxNotEnabled);
         }
 
         unsafe {
             // Execute VMXOFF.
             vmx::vmxoff().map_err(|err| {
-                ax_err_type!(
-                    BadState,
-                    format_args!("VMX instruction vmxoff failed: {:?}", err)
-                )
+                VmxError::VmxInstructionError(format!("VMX instruction vmxoff failed: {:?}", err))
             })?;
             // Remove VMXE bit in CR4.
             Cr4::update(|cr4| cr4.remove(Cr4Flags::VIRTUAL_MACHINE_EXTENSIONS));