重构虚拟机内存管理，添加内存区域支持，更新 RunData 结构，优化设备信息管理

Author: ZR233

src/arch/aarch64/mod.rs

@@ -64,13 +64,3 @@ impl fmt::Display for VmId {
     }
 }
 
-/// Data needed when VM is running
-pub struct RunData {
-    vcpus: Vec<VCpu>,
-    address_space: AddrSpace,
-    devices: BTreeMap<String, DeviceInfo>,
-}
-
-/// Information about a device in the VM
-#[derive(Debug, Clone)]
-pub struct DeviceInfo {}

src/arch/aarch64/vm.rs

@@ -4,11 +4,12 @@ use super::AddrSpace;
 use alloc::{collections::BTreeMap, string::String, vec::Vec};
 
 use crate::{
-    GuestPhysAddr,
-    arch::{RunData, cpu::VCpu},
-    config::AxVMConfig,
-    vhal::cpu::CpuId,
+    arch::cpu::VCpu,
+    config::{AxVMConfig, MemoryKind},
+    region::Region,
+    vhal::{cpu::CpuId, phys_to_virt},
     vm::{Status, VmId, VmOps},
+    {GuestPhysAddr, HostPhysAddr, HostVirtAddr},
 };
 
 const VM_ASPACE_BASE: usize = 0x0;
@@ -47,11 +48,6 @@ impl ArchVm {
 
         // Create vCPUs
         let mut vcpus = Vec::new();
-        // let dtb_addr = config
-        //     .image_config
-        //     .dtb_load_gpa
-        //     .map(|d| d.as_usize())
-        //     .unwrap_or_default();
 
         let dtb_addr = GuestPhysAddr::from_usize(0);
 
@@ -94,8 +90,24 @@ impl ArchVm {
         )
         .map_err(|e| anyhow::anyhow!("Failed to create address space: {:?}", e))?;
 
-        // // Initialize devices
-        // let mut devices = BTreeMap::new();
+        let mut run_data = RunData {
+            vcpus,
+            address_space,
+            regions: Vec::new(),
+            devices: BTreeMap::new(),
+        };
+
+        debug!("Mapping memory regions for VM {} ({})", self.id, self.name);
+        for memory_cfg in config.memory_regions {
+            run_data.add_memory_region(memory_cfg)?;
+        }
+
+        debug!(
+            "Mapped {} memory regions for VM {} ({})",
+            run_data.regions.len(),
+            self.id,
+            self.name
+        );
 
         // // Add emulated devices
         // for emu_device in config.emu_devices() {
@@ -184,11 +196,7 @@ impl ArchVm {
         //         .map_err(|e| anyhow::anyhow!("Failed to setup vCPU {}: {:?}", vcpu_id, e))?;
         // }
 
-        // self.state = Some(StateMachine::Inited(RunData {
-        //     vcpus,
-        //     address_space,
-        //     devices,
-        // }));
+        self.state = Some(StateMachine::Inited(run_data));
 
         Ok(())
     }
@@ -499,3 +507,36 @@ enum StateMachine {
     ShuttingDown(RunData),
     PoweredOff,
 }
+
+/// Data needed when VM is running
+pub struct RunData {
+    vcpus: Vec<VCpu>,
+    address_space: AddrSpace,
+    regions: Vec<Region>,
+    devices: BTreeMap<String, DeviceInfo>,
+}
+
+impl RunData {
+    fn add_memory_region(&mut self, config: MemoryKind) -> anyhow::Result<()> {
+        let region = Region::new(config);
+        self.address_space
+            .map_linear(
+                region.gpa.as_usize().into(),
+                region.hva.as_usize().into(),
+                region.size,
+                axaddrspace::MappingFlags::READ
+                    | axaddrspace::MappingFlags::WRITE
+                    | axaddrspace::MappingFlags::EXECUTE
+                    | axaddrspace::MappingFlags::USER,
+            )
+            .map_err(|e| anyhow::anyhow!("Failed to map memory region: {:?}", e))?;
+
+        self.regions.push(region);
+
+        Ok(())
+    }
+}
+
+/// Information about a device in the VM
+#[derive(Debug, Clone)]
+pub struct DeviceInfo {}

src/config.rs

@@ -4,7 +4,7 @@
 use alloc::string::String;
 use alloc::vec::Vec;
 
-use axvm_types::addr::GuestPhysAddr;
+use crate::{GuestPhysAddr, HostPhysAddr};
 
 pub use axvmconfig::{
     AxVMCrateConfig, EmulatedDeviceConfig, PassThroughAddressConfig, PassThroughDeviceConfig,
@@ -51,6 +51,16 @@ pub struct VMImagesConfig {
     pub ramdisk: Option<VMImageConfig>,
 }
 
+#[derive(Debug, Clone)]
+pub enum MemoryKind {
+    /// Use identical memory regions
+    Identical { size: usize },
+    /// Use memory regions mapped from host physical address
+    Passthrough { hpa: HostPhysAddr, size: usize },
+    /// Use fixed memory regions
+    Fixed { gpa: GuestPhysAddr, size: usize },
+}
+
 /// A part of `AxVMCrateConfig`, which represents a `VM`.
 #[derive(Debug, Default)]
 pub struct AxVMConfig {
@@ -63,6 +73,7 @@ pub struct AxVMConfig {
     pub pass_through_devices: Vec<PassThroughDeviceConfig>,
     pub excluded_devices: Vec<Vec<String>>,
     pub pass_through_addresses: Vec<PassThroughAddressConfig>,
+    pub memory_regions: Vec<MemoryKind>,
     // TODO: improve interrupt passthrough
     pub spi_list: Vec<u32>,
     pub interrupt_mode: VMInterruptMode,

src/lib.rs

@@ -25,6 +25,7 @@ pub(crate) mod arch;
 mod fdt;
 mod vcpu;
 mod vm;
+mod region;
 
 pub mod config;
 pub mod vhal;

src/region.rs

@@ -0,0 +1,76 @@
+use core::{alloc::Layout, ops::Range};
+
+use alloc::vec::Vec;
+
+use crate::{
+    GuestPhysAddr, HostVirtAddr,
+    config::MemoryKind,
+    vhal::{phys_to_virt, virt_to_phys},
+};
+
+const ALIGN: usize = 1024 * 1024 * 2;
+
+#[derive(Debug, Clone)]
+pub struct Region {
+    pub gpa: GuestPhysAddr,
+    pub hva: HostVirtAddr,
+    pub size: usize,
+    pub own: bool,
+}
+
+impl Region {
+    pub fn new(kind: MemoryKind) -> Self {
+        match kind {
+            MemoryKind::Identical { size } => {
+                let hva = HostVirtAddr::from(unsafe {
+                    alloc::alloc::alloc(Layout::from_size_align_unchecked(size, ALIGN))
+                } as usize);
+                let gpa = GuestPhysAddr::from_usize(virt_to_phys(hva).as_usize());
+                Region {
+                    gpa,
+                    hva,
+                    size,
+                    own: true,
+                }
+            }
+            MemoryKind::Passthrough { hpa, size } => {
+                let hva = phys_to_virt(hpa);
+                let gpa = GuestPhysAddr::from_usize(hva.as_usize());
+                Region {
+                    gpa,
+                    hva,
+                    size,
+                    own: false,
+                }
+            }
+            MemoryKind::Fixed { gpa, size } => {
+                let hva = HostVirtAddr::from(unsafe {
+                    alloc::alloc::alloc(Layout::from_size_align_unchecked(size, ALIGN))
+                } as usize);
+                Region {
+                    gpa,
+                    hva,
+                    size,
+                    own: true,
+                }
+            }
+        }
+    }
+
+    pub fn buffer_mut(&self) -> &mut [u8] {
+        unsafe { core::slice::from_raw_parts_mut(self.hva.as_mut_ptr(), self.size) }
+    }
+}
+
+impl Drop for Region {
+    fn drop(&mut self) {
+        if self.own {
+            unsafe {
+                alloc::alloc::dealloc(
+                    self.hva.as_mut_ptr(),
+                    alloc::alloc::Layout::from_size_align(self.size, ALIGN).unwrap(),
+                );
+            }
+        }
+    }
+}

src/vhal/mod.rs

@@ -12,6 +12,7 @@ use crate::{
         cpu::{CpuHardId, CpuId},
         precpu::PreCpuSet,
     },
+    {HostPhysAddr, HostVirtAddr},
 };
 use axconfig::TASK_STACK_SIZE;
 use axtask::AxCpuMask;
@@ -82,3 +83,15 @@ pub(crate) trait ArchHal {
 pub(crate) trait ArchCpuData {
     fn hard_id(&self) -> CpuHardId;
 }
+
+pub fn phys_to_virt(paddr: HostPhysAddr) -> HostVirtAddr {
+    axhal::mem::phys_to_virt(paddr.as_usize().into())
+        .as_usize()
+        .into()
+}
+
+pub fn virt_to_phys(vaddr: HostVirtAddr) -> HostPhysAddr {
+    axhal::mem::virt_to_phys(vaddr.as_usize().into())
+        .as_usize()
+        .into()
+}