feat: refactor memory management and introduce PhysFrame abstraction

Author: ZR233

Cargo.toml

@@ -13,11 +13,11 @@ keywords = ["x86", "vcpu", "hypervisor", "arceos"]
 license = "GPL-3.0-or-later OR Apache-2.0 OR MulanPSL-2.0" # MulanPubL2 is not included in SPDX
 
 [dependencies]
-log = "0.4.19"
+log = "0.4"
 cfg-if = "1.0"
 bitflags = "2.2"
 bit_field = "0.10"
-paste = "1.0.15"
+paste = "1.0"
 x86 = "0.52"
 x86_64 = "0.15"
 raw-cpuid = "11.0"
@@ -28,11 +28,10 @@ page_table_entry = "0.5"
 memory_addr = "0.4"
 crate_interface = "0.1"
 
-axaddrspace = "0.2.0"
+# axaddrspace = "0.2.0"
 axvcpu = "0.1.0"
 x86_vlapic = "0.1.0"
 axdevice_base = "0.1.0"
-axvisor_api = "0.1.0"
 
 spin = { version = "0.9", default-features = false }
 

src/lib.rs

@@ -15,6 +15,7 @@ pub(crate) mod msr;
 #[macro_use]
 pub(crate) mod regs;
 mod ept;
+pub(crate) mod mem;
 
 cfg_if::cfg_if! {
     if #[cfg(feature = "vmx")] {
@@ -30,3 +31,45 @@ cfg_if::cfg_if! {
 pub use ept::GuestPageWalkInfo;
 pub use regs::GeneralRegisters;
 pub use vender::has_hardware_support;
+
+pub type HostVirtAddr = usize;
+pub type HostPhysAddr = usize;
+
+/// Hardware abstraction layer for memory management.
+pub trait Hal {
+    /// Allocates a frame and returns its host physical address. The
+    ///
+    /// # Returns
+    ///
+    /// * `Option<HostPhysAddr>` - Some containing the physical address of the allocated frame, or None if allocation fails.
+    fn alloc_frame() -> Option<HostPhysAddr>;
+
+    /// Deallocates a frame given its physical address.
+    ///
+    /// # Parameters
+    ///
+    /// * `paddr` - The physical address of the frame to deallocate.
+    fn dealloc_frame(paddr: HostPhysAddr);
+
+    /// Converts a host physical address to a host virtual address.
+    ///
+    /// # Parameters
+    ///
+    /// * `paddr` - The physical address to convert.
+    ///
+    /// # Returns
+    ///
+    /// * `HostVirtAddr` - The corresponding virtual address.
+    fn phys_to_virt(paddr: HostPhysAddr) -> HostVirtAddr;
+
+    /// Converts a host virtual address to a host physical address.
+    ///
+    /// # Parameters
+    ///
+    /// * `vaddr` - The virtual address to convert.
+    ///
+    /// # Returns
+    ///
+    /// * `HostPhysAddr` - The corresponding physical address.
+    fn virt_to_phys(vaddr: HostVirtAddr) -> HostPhysAddr;
+}

src/mem.rs

@@ -0,0 +1,70 @@
+use core::marker::PhantomData;
+
+use crate::{Hal, HostPhysAddr};
+
+/// A physical frame which will be automatically deallocated when dropped.
+///
+/// The frame is allocated using the [`AxMmHal`] implementation. The size of the frame is likely to
+/// be 4 KiB but the actual size is determined by the [`AxMmHal`] implementation.
+#[derive(Debug)]
+pub struct PhysFrame<H: Hal> {
+    start_paddr: Option<HostPhysAddr>,
+    _marker: PhantomData<H>,
+}
+
+impl<H: Hal> PhysFrame<H> {
+    /// Allocate a [`PhysFrame`].
+    pub fn alloc() -> AxResult<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(Self {
+            start_paddr: Some(start_paddr),
+            _marker: PhantomData,
+        })
+    }
+
+    /// Allocate a [`PhysFrame`] and fill it with zeros.
+    pub fn alloc_zero() -> AxResult<Self> {
+        let mut f = Self::alloc()?;
+        f.fill(0);
+        Ok(f)
+    }
+
+    /// Create an uninitialized [`PhysFrame`].
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that the [`PhysFrame`] is only used as a placeholder and never
+    /// accessed.
+    pub const unsafe fn uninit() -> Self {
+        Self {
+            start_paddr: None,
+            _marker: PhantomData,
+        }
+    }
+
+    /// Get the starting physical address of the frame.
+    pub fn start_paddr(&self) -> HostPhysAddr {
+        self.start_paddr.expect("uninitialized PhysFrame")
+    }
+
+    /// 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()
+    }
+
+    /// Fill the frame with a byte. Works only when the frame is 4 KiB in size.
+    pub fn fill(&mut self, byte: u8) {
+        unsafe { core::ptr::write_bytes(self.as_mut_ptr(), byte, PAGE_SIZE) }
+    }
+}
+
+impl<H: AxMmHal> Drop for PhysFrame<H> {
+    fn drop(&mut self) {
+        if let Some(start_paddr) = self.start_paddr {
+            H::dealloc_frame(start_paddr);
+            debug!("[AxVM] deallocated PhysFrame({start_paddr:#x})");
+        }
+    }
+}

src/vmx/structs.rs

@@ -3,14 +3,17 @@ use bitflags::bitflags;
 
 use memory_addr::PAGE_SIZE_4K as PAGE_SIZE;
 
-use axaddrspace::{AxMmHal, HostPhysAddr, PhysFrame};
 use axerrno::AxResult;
 
-use crate::msr::{Msr, MsrReadWrite};
+use crate::{
+    Hal, HostPhysAddr,
+    mem::PhysFrame,
+    msr::{Msr, MsrReadWrite},
+};
 
 /// VMCS/VMXON region in 4K size. (SDM Vol. 3C, Section 24.2)
 #[derive(Debug)]
-pub struct VmxRegion<H: AxMmHal> {
+pub struct VmxRegion<H: Hal> {
     frame: PhysFrame<H>,
 }
 

src/vmx/vcpu.rs

@@ -22,7 +22,6 @@ use axaddrspace::{
 use axdevice_base::BaseDeviceOps;
 use axerrno::{AxResult, ax_err, ax_err_type};
 use axvcpu::{AxArchVCpu, AxVCpuExitReason, AxVCpuHal};
-use axvisor_api::vmm::{VCpuId, VMId};
 
 use super::VmxExitInfo;
 use super::as_axerr;
@@ -32,13 +31,16 @@ use super::vmcs::{
     self, ApicAccessExitType, VmcsControl32, VmcsControl64, VmcsControlNW, VmcsGuest16,
     VmcsGuest32, VmcsGuest64, VmcsGuestNW, VmcsHost16, VmcsHost32, VmcsHost64, VmcsHostNW,
 };
-use crate::{ept::GuestPageWalkInfo, msr::Msr, regs::GeneralRegisters};
+use crate::{Hal, ept::GuestPageWalkInfo, msr::Msr, regs::GeneralRegisters};
 
 const VMX_PREEMPTION_TIMER_SET_VALUE: u32 = 1_000_000;
 
 const QEMU_EXIT_PORT: u16 = 0x604;
 const QEMU_EXIT_MAGIC: u64 = 0x2000;
 
+pub type VCpuId = usize;
+pub type VMId = usize;
+
 pub struct XState {
     host_xcr0: u64,
     guest_xcr0: u64,
@@ -153,7 +155,7 @@ const CR0_PE: usize = 1 << 0;
 
 /// A virtual CPU within a guest.
 #[repr(C)]
-pub struct VmxVcpu<H: AxVCpuHal> {
+pub struct VmxVcpu<H: Hal> {
     // The order of `guest_regs` and `host_stack_top` is mandatory. They must be the first two fields. If you want to
     // change the order or the type of these fields, you must also change the assembly in this file.
     /// Guest general-purpose registers.
@@ -175,11 +177,11 @@ pub struct VmxVcpu<H: AxVCpuHal> {
 
     // VMCS-related fields
     /// The VMCS region.
-    vmcs: VmxRegion<H::MmHal>,
+    vmcs: VmxRegion<H>,
     /// The I/O bitmap for the VMCS.
-    io_bitmap: IOBitmap<H::MmHal>,
+    io_bitmap: IOBitmap<H>,
     /// The MSR bitmap for the VMCS.
-    msr_bitmap: MsrBitmap<H::MmHal>,
+    msr_bitmap: MsrBitmap<H>,
 
     // Interrupt-related fields
     /// Pending events to be injected to the guest.