feat: add cache flush

ZR233 · ZR233 · commit db7db820c048 · 2025-11-27T10:36:28.000+08:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -36,10 +36,9 @@ axaddrspace = "0.2"
 # axdevice_base = "0.1"
 # axvcpu = "0.1"
 axvmconfig = {version = "0.1", default-features = false}
-axconfig = {workspace = true}
-axhal.workspace = true
 axruntime.workspace = true
-axtask.workspace = true
+axhal.workspace = true
+axstd.workspace = true
 axvm-types.workspace = true
 
 [target.'cfg(target_arch = "x86_64")'.dependencies]
diff --git a/src/arch/aarch64/cpu.rs b/src/arch/aarch64/cpu.rs
@@ -6,9 +6,12 @@ use arm_vcpu::{Aarch64PerCpu, Aarch64VCpuCreateConfig};
 use axhal::percpu::this_cpu_id;
 use axvm_types::addr::*;
 
-use crate::vhal::{
-    ArchCpuData,
-    cpu::{CpuHardId, CpuId, HCpuExclusive},
+use crate::{
+    TASK_STACK_SIZE, VmId,
+    vhal::{
+        ArchCpuData,
+        cpu::{CpuHardId, CpuId, HCpuExclusive},
+    },
 };
 
 pub struct HCpu {
@@ -106,4 +109,14 @@ impl VCpu {
     {
         self.hcpu.with_cpu(f)
     }
+
+    pub fn binded_cpu_id(&self) -> CpuId {
+        self.hcpu.cpu_id()
+    }
+
+    pub fn run(&mut self) -> anyhow::Result<()> {
+        info!("Starting vCPU {}", self.id);
+
+        Ok(())
+    }
 }
diff --git a/src/arch/aarch64/mod.rs b/src/arch/aarch64/mod.rs
@@ -42,6 +42,7 @@ impl ArchHal for Hal {
 
     fn init() -> anyhow::Result<()> {
         arm_vcpu::init_hal(&cpu::VCpuHal);
+     
         Ok(())
     }
 
@@ -62,10 +63,3 @@ impl ArchHal for Hal {
         dcache_range(CacheOp::CleanAndInvalidate, vaddr.as_usize(), size);
     }
 }
-
-// Implement Display for VmId
-impl fmt::Display for VmId {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "VmId({:?})", self)
-    }
-}
diff --git a/src/arch/aarch64/vm.rs b/src/arch/aarch64/vm.rs
@@ -1,13 +1,15 @@
 use core::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
+use std::os::arceos::{api::task::AxCpuMask, modules::axtask::set_current_affinity};
 
 use super::AddrSpace;
 use alloc::{collections::BTreeMap, string::String, vec::Vec};
+use arm_vcpu::Aarch64VCpuSetupConfig;
 
 use crate::{
-    GuestPhysAddr, HostPhysAddr, HostVirtAddr,
+    GuestPhysAddr, HostPhysAddr, HostVirtAddr, TASK_STACK_SIZE,
     arch::cpu::VCpu,
     config::{AxVMConfig, MemoryKind},
-    region::Region,
+    region::GuestRegion,
     vhal::{ArchHal, cpu::CpuId, phys_to_virt, virt_to_phys},
     vm::{Status, VmId, VmOps},
 };
@@ -115,12 +117,8 @@ impl ArchVm {
         );
 
         run_data.load_images(&config)?;
-        for vcpu in &mut run_data.vcpus {
-            vcpu.vcpu.set_entry(run_data.kernel_entry).unwrap();
-            vcpu.vcpu.set_dtb_addr(run_data.dtb_addr).unwrap();
-        }
 
-        // // Add emulated devices
+        // Add emulated devices
         // for emu_device in config.emu_devices() {
         //     let device_info = DeviceInfo {
         //         device_type: DeviceType::Emulated,
@@ -176,36 +174,27 @@ impl ArchVm {
         //     })?;
         // }
 
-        // // Setup vCPUs
-        // for (vcpu_id, vcpu) in &vcpus {
-        //     let entry = if *vcpu_id == 0 {
-        //         config.bsp_entry()
-        //     } else {
-        //         config.ap_entry()
-        //     };
-
-        //     let setup_config = AxVCpuSetupConfig {
-        //         passthrough_interrupt: config.interrupt_mode()
-        //             == axvmconfig::VMInterruptMode::Passthrough,
-        //         passthrough_timer: config.interrupt_mode()
-        //             == axvmconfig::VMInterruptMode::Passthrough,
-        //     };
+        // Setup vCPUs
+        for vcpu in &mut run_data.vcpus {
+            vcpu.vcpu.set_entry(run_data.kernel_entry).unwrap();
+            vcpu.vcpu.set_dtb_addr(run_data.dtb_addr).unwrap();
 
-        //     // Set entry point first
-        //     vcpu.set_entry(entry).map_err(|e| {
-        //         anyhow::anyhow!("Failed to set entry for vCPU {}: {:?}", vcpu_id, e)
-        //     })?;
+            let setup_config = Aarch64VCpuSetupConfig {
+                passthrough_interrupt: config.interrupt_mode()
+                    == axvmconfig::VMInterruptMode::Passthrough,
+                passthrough_timer: config.interrupt_mode()
+                    == axvmconfig::VMInterruptMode::Passthrough,
+            };
 
-        //     // Set EPT root
-        //     vcpu.set_ept_root(address_space.page_table_root())
-        //         .map_err(|e| {
-        //             anyhow::anyhow!("Failed to set EPT root for vCPU {}: {:?}", vcpu_id, e)
-        //         })?;
+            vcpu.vcpu
+                .setup(setup_config)
+                .map_err(|e| anyhow::anyhow!("Failed to setup vCPU : {e:?}"))?;
 
-        //     // Setup vCPU with configuration
-        //     vcpu.setup(setup_config)
-        //         .map_err(|e| anyhow::anyhow!("Failed to setup vCPU {}: {:?}", vcpu_id, e))?;
-        // }
+            // Set EPT root
+            vcpu.vcpu
+                .set_ept_root(run_data.address_space.page_table_root())
+                .map_err(|e| anyhow::anyhow!("Failed to set EPT root for vCPU : {e:?}"))?;
+        }
 
         self.state = StateMachine::Inited(run_data);
 
@@ -318,29 +307,44 @@ impl VmOps for ArchVm {
             _ => return Err(anyhow::anyhow!("VM is not in Inited state")),
         };
 
-        // Transition to Running state
-        // let new_data = RunData {
-        //     // vcpus: BTreeMap::new(),
-        //     // address_space: AddrSpace::new_empty(4, GuestPhysAddr::from(0), 0).unwrap(),
-        //     devices: BTreeMap::new(),
-        // };
-        // let old_data = core::mem::replace(data, new_data);
-        // self.transition_state(StateMachine::Running(old_data))?;
-
-        // // Start all vCPUs
-        // let vcpus = self.get_vcpus();
-        // for (vcpu_id, vcpu) in vcpus.iter().enumerate() {
-        //     debug!("Starting vCPU {} for VM {}", vcpu_id, self.id);
-        //     vcpu.bind()
-        //         .map_err(|e| anyhow::anyhow!("Failed to bind vCPU {}: {:?}", vcpu_id, e))?;
-        // }
+        let mut vcpus = vec![];
+        vcpus.append(&mut data.vcpus);
+        let mut vcpu_handles = vec![];
+        let vm_id = self.id;
+        for mut vcpu in vcpus.into_iter() {
+            let vcpu_id = vcpu.id;
+            let bind_id = vcpu.binded_cpu_id();
+            let handle = std::thread::Builder::new()
+                .name(format!("{}-{vcpu_id}", self.id,))
+                .stack_size(TASK_STACK_SIZE)
+                .spawn(move || {
+                    assert!(
+                        set_current_affinity(AxCpuMask::one_shot(bind_id.raw())),
+                        "Initialize CPU affinity failed!"
+                    );
+                    match vcpu.run() {
+                        Ok(()) => {
+                            info!("vCPU {} of VM {} exited normally", vcpu_id, vm_id);
+                        }
+                        Err(e) => {
+                            error!(
+                                "vCPU {} of VM {} exited with error: {:?}",
+                                vcpu_id, vm_id, e
+                            );
+                        }
+                    }
+                })
+                .map_err(|e| anyhow!("{e}"))?;
+
+            vcpu_handles.push(handle);
+        }
 
-        // info!(
-        //     "VM {} ({}) booted successfully with {} vCPUs",
-        //     self.id,
-        //     self.name,
-        //     vcpus.len()
-        // );
+        info!(
+            "VM {} ({}) with {} cpus booted successfully.",
+            self.id,
+            self.name,
+            vcpu_handles.len()
+        );
 
         Ok(())
     }
@@ -523,7 +527,7 @@ enum StateMachine {
 pub struct RunData {
     vcpus: Vec<VCpu>,
     address_space: AddrSpace,
-    regions: Vec<Region>,
+    regions: Vec<GuestRegion>,
     devices: BTreeMap<String, DeviceInfo>,
     kernel_entry: GuestPhysAddr,
     dtb_addr: GuestPhysAddr,
@@ -534,7 +538,7 @@ pub struct RunData {
 
 impl RunData {
     fn add_memory_region(&mut self, config: &MemoryKind) -> anyhow::Result<()> {
-        let region = Region::new(config);
+        let region = GuestRegion::new(config);
         self.address_space
             .map_linear(
                 region.gpa.as_usize().into(),
diff --git a/src/lib.rs b/src/lib.rs
@@ -16,7 +16,9 @@ extern crate log;
 #[macro_use]
 extern crate anyhow;
 
-const TASK_STACK_SIZE: usize = 0x40000; // 16KB
+extern crate axstd as std;
+
+const TASK_STACK_SIZE: usize = 0x40000; // 256 KB
 
 #[cfg_attr(target_arch = "aarch64", path = "arch/aarch64/mod.rs")]
 #[cfg_attr(target_arch = "x86_64", path = "arch/x86_64/mod.rs")]
diff --git a/src/region.rs b/src/region.rs
@@ -11,22 +11,22 @@ use crate::{
 const ALIGN: usize = 1024 * 1024 * 2;
 
 #[derive(Debug, Clone)]
-pub struct Region {
+pub struct GuestRegion {
     pub gpa: GuestPhysAddr,
     pub hva: HostVirtAddr,
     pub size: usize,
     pub own: bool,
 }
 
-impl Region {
+impl GuestRegion {
     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 {
+                GuestRegion {
                     gpa,
                     hva,
                     size: *size,
@@ -36,7 +36,7 @@ impl Region {
             MemoryKind::Passthrough { hpa, size } => {
                 let hva = phys_to_virt(*hpa);
                 let gpa = GuestPhysAddr::from_usize(hva.as_usize());
-                Region {
+                GuestRegion {
                     gpa,
                     hva,
                     size: *size,
@@ -47,7 +47,7 @@ impl Region {
                 let hva = HostVirtAddr::from(unsafe {
                     alloc::alloc::alloc(Layout::from_size_align_unchecked(*size, ALIGN))
                 } as usize);
-                Region {
+                GuestRegion {
                     gpa: *gpa,
                     hva,
                     size: *size,
@@ -62,7 +62,7 @@ impl Region {
     }
 }
 
-impl Drop for Region {
+impl Drop for GuestRegion {
     fn drop(&mut self) {
         if self.own {
             unsafe {
diff --git a/src/vhal/cpu.rs b/src/vhal/cpu.rs
@@ -14,6 +14,10 @@ pub(super) static HCPU_ALLOC: Mutex<BitAlloc4K> = Mutex::new(BitAlloc4K::DEFAULT
 pub struct HCpuExclusive(CpuId);
 
 impl HCpuExclusive {
+    pub fn id(&self) -> CpuId {
+        self.0
+    }
+
     pub fn try_new(id: Option<CpuId>) -> Option<Self> {
         let mut a = HCPU_ALLOC.lock();
         match id {
diff --git a/src/vhal/mod.rs b/src/vhal/mod.rs
@@ -1,4 +1,8 @@
 use alloc::{collections::BTreeMap, vec::Vec};
+use axstd::{
+    os::arceos::{api::task::AxCpuMask, modules::axtask::set_current_affinity},
+    thread::yield_now,
+};
 use bitmap_allocator::{BitAlloc, BitAlloc4K};
 use core::{
     fmt::Display,
@@ -7,15 +11,13 @@ use core::{
 use spin::Mutex;
 
 use crate::{
+    HostPhysAddr, HostVirtAddr, TASK_STACK_SIZE,
     arch::{HCpu, Hal},
     vhal::{
         cpu::{CpuHardId, CpuId},
         precpu::PreCpuSet,
     },
-    {HostPhysAddr, HostVirtAddr},
 };
-use axconfig::TASK_STACK_SIZE;
-use axtask::AxCpuMask;
 
 pub(crate) mod cpu;
 pub(crate) mod precpu;
@@ -30,42 +32,42 @@ pub fn init() -> anyhow::Result<()> {
 
     info!("Initializing VHal for {cpu_count} CPUs...");
     cpu::PRE_CPU.init();
+
     for cpu_id in 0..cpu_count {
         let id = CpuId::new(cpu_id);
-        let _handle = axtask::spawn_raw(
-            move || {
+        axstd::thread::Builder::new()
+            .name(format!("init-cpu-{}", cpu_id))
+            .stack_size(TASK_STACK_SIZE)
+            .spawn(move || {
                 info!("Core {cpu_id} is initializing hardware virtualization support...");
                 // Initialize cpu affinity here.
                 assert!(
-                    axtask::set_current_affinity(AxCpuMask::one_shot(cpu_id)),
+                    set_current_affinity(AxCpuMask::one_shot(cpu_id)),
                     "Initialize CPU affinity failed!"
                 );
                 info!("Enabling hardware virtualization support on core {id}");
                 timer::init_percpu();
 
-                let cpu_data = Hal::current_cpu_init(id).expect("Enable virtualization failed!");
-                unsafe { cpu::PRE_CPU.set(cpu_data.hard_id(), cpu_data) };
+                // let cpu_data = Hal::current_cpu_init(id).expect("Enable virtualization failed!");
+                // unsafe { cpu::PRE_CPU.set(cpu_data.hard_id(), cpu_data) };
                 let _ = CORES.fetch_add(1, Ordering::Release);
-            },
-            format!("init-cpu-{}", cpu_id),
-            TASK_STACK_SIZE,
-        );
-        // handles.push(_handle);
+            })
+            .map_err(|e| anyhow!("{e:?}"))?;
     }
     info!("Waiting for all cores to enable hardware virtualization...");
 
     // Wait for all cores to enable virtualization.
     while CORES.load(Ordering::Acquire) != cpu_count {
         // Use `yield_now` instead of `core::hint::spin_loop` to avoid deadlock.
-        axtask::yield_now();
+        yield_now();
     }
-    // for handle in handles {
-    //     handle.join();
-    // }
 
     cpu::HCPU_ALLOC.lock().insert(0..cpu_count);
 
     info!("All cores have enabled hardware virtualization support.");
+
+
+
     Ok(())
 }
 
diff --git a/src/vm.rs b/src/vm.rs

Original file line number	Diff line number	Diff line change
`@@ -42,6 +42,7 @@ impl ArchHal for Hal {`
`42`	`42`
`43`	`43`	`fn init() -> anyhow::Result<()> {`
`44`	`44`	`arm_vcpu::init_hal(&cpu::VCpuHal);`
	`45`	`+`
`45`	`46`	`Ok(())`
`46`	`47`	`}`
`47`	`48`
`@@ -62,10 +63,3 @@ impl ArchHal for Hal {`
`62`	`63`	`dcache_range(CacheOp::CleanAndInvalidate, vaddr.as_usize(), size);`
`63`	`64`	`}`
`64`	`65`	`}`
`65`		`-`
`66`		`-// Implement Display for VmId`
`67`		`-impl fmt::Display for VmId {`
`68`		`- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {`
`69`		`- write!(f, "VmId({:?})", self)`
`70`		`- }`
`71`		`-}`