update

Author: ZR233

src/arch/aarch64/cpu.rs

@@ -1,13 +1,17 @@
-use core::{fmt::Display, sync::atomic::AtomicBool};
+use core::{fmt::Display, ops::Deref, sync::atomic::AtomicBool};
 use std::sync::Arc;
 
 use aarch64_cpu::registers::*;
 use arm_vcpu::{Aarch64PerCpu, Aarch64VCpuCreateConfig};
 use axvm_types::addr::*;
 
-use crate::vhal::{
-    ArchCpuData,
-    cpu::{CpuHardId, CpuId, HCpuExclusive},
+use crate::{
+    data2::VmDataWeak,
+    vcpu::VCpuCommon,
+    vhal::{
+        ArchCpuData,
+        cpu::{CpuHardId, CpuId, HCpuExclusive},
+    },
 };
 
 pub struct HCpu {
@@ -97,53 +101,34 @@ impl VCpuHandle {
 }
 
 pub struct VCpu {
-    pub id: CpuHardId,
     pub vcpu: arm_vcpu::Aarch64VCpu,
-    hcpu: HCpuExclusive,
-    handle: VCpuHandle,
+    common: VCpuCommon,
 }
 
 impl VCpu {
-    pub fn new(host_cpuid: Option<CpuId>, dtb_addr: GuestPhysAddr) -> anyhow::Result<Self> {
-        let hcpu_exclusive = HCpuExclusive::try_new(host_cpuid)
-            .ok_or_else(|| anyhow!("Failed to allocate cpu with id `{host_cpuid:?}`"))?;
+    pub fn new(
+        host_cpuid: Option<CpuId>,
+        dtb_addr: GuestPhysAddr,
+        vm: VmDataWeak,
+    ) -> anyhow::Result<Self> {
+        let common = VCpuCommon::new_exclusive(host_cpuid, vm)?;
 
-        let hard_id = hcpu_exclusive.hard_id();
+        let hard_id = common.hard_id();
 
         let vcpu = arm_vcpu::Aarch64VCpu::new(Aarch64VCpuCreateConfig {
             mpidr_el1: hard_id.raw() as u64,
             dtb_addr: dtb_addr.as_usize(),
         })
         .unwrap();
-        Ok(VCpu {
-            id: hard_id,
-            vcpu,
-            hcpu: hcpu_exclusive,
-            handle: VCpuHandle::new(),
-        })
-    }
-
-    pub fn handle(&self) -> VCpuHandle {
-        self.handle.clone()
-    }
-
-    pub fn with_hcpu<F, R>(&self, f: F) -> R
-    where
-        F: FnOnce(&HCpu) -> R,
-    {
-        self.hcpu.with_cpu(f)
-    }
-
-    pub fn binded_cpu_id(&self) -> CpuId {
-        self.hcpu.cpu_id()
+        Ok(VCpu { vcpu, common })
     }
 
     pub fn run(&mut self) -> anyhow::Result<()> {
-        info!("Starting vCPU {}", self.id);
+        info!("Starting vCPU {}", self.id());
 
-        while self.handle.is_active() {
+        while self.is_active() {
             let exit_reason = self.vcpu.run().map_err(|e| anyhow!("{e}"))?;
-            debug!("vCPU {} exited with reason: {:?}", self.id, exit_reason);
+            debug!("vCPU {} exited with reason: {:?}", self.id(), exit_reason);
             match exit_reason {
                 arm_vcpu::AxVCpuExitReason::Hypercall { nr, args } => todo!(),
                 arm_vcpu::AxVCpuExitReason::MmioRead {
@@ -163,7 +148,10 @@ impl VCpu {
                     arg,
                 } => todo!(),
                 arm_vcpu::AxVCpuExitReason::CpuDown { _state } => todo!(),
-                arm_vcpu::AxVCpuExitReason::SystemDown => todo!(),
+                arm_vcpu::AxVCpuExitReason::SystemDown => {
+                    info!("vCPU {} requested system shutdown", self.common.bind_id);
+                    self.shutdown()?;
+                }
                 arm_vcpu::AxVCpuExitReason::Nothing => {}
                 arm_vcpu::AxVCpuExitReason::SendIPI {
                     target_cpu,
@@ -179,3 +167,11 @@ impl VCpu {
         Ok(())
     }
 }
+
+impl Deref for VCpu {
+    type Target = VCpuCommon;
+
+    fn deref(&self) -> &Self::Target {
+        &self.common
+    }
+}

src/arch/aarch64/vm/init.rs

@@ -8,9 +8,10 @@ use std::{
 use arm_vcpu::Aarch64VCpuSetupConfig;
 
 use crate::{
-    GuestPhysAddr, TASK_STACK_SIZE, VmData, VmStatusInitOps,
+    GuestPhysAddr, TASK_STACK_SIZE, VmRunCommonData, VmStatusInitOps,
     arch::{VmStatusRunning, cpu::VCpu},
     config::AxVMConfig,
+    data2::VmDataWeak,
     vm::{MappingFlags, VmId},
 };
 
@@ -19,26 +20,27 @@ const VM_ASPACE_SIZE: usize = 0x7fff_ffff_f000;
 const VM_ASPACE_END: GuestPhysAddr =
     GuestPhysAddr::from_usize(VM_ASPACE_BASE.as_usize() + VM_ASPACE_SIZE);
 
-pub struct VmInit {
+pub struct VmMachineInited {
     pub id: VmId,
     pub name: String,
-    pt_levels: usize,
-    stop_requested: AtomicBool,
-    run_data: Option<VmStatusRunning>,
+    // pt_levels: usize,
+    // stop_requested: AtomicBool,
+    pub run_data: VmStatusRunning,
 }
 
-impl VmInit {
+impl VmMachineInited {
     /// Creates a new VM with the given configuration
-    pub fn new(config: &AxVMConfig) -> anyhow::Result<Self> {
-        let vm = Self {
-            id: config.id().into(),
-            name: config.name(),
-            pt_levels: 4,
-            stop_requested: AtomicBool::new(false),
-            run_data: None,
-        };
-        Ok(vm)
-    }
+    // pub fn new(config: &AxVMConfig) -> anyhow::Result<Self> {
+    //     let vm = Self {
+    //         id: config.id().into(),
+    //         name: config.name().into(),
+    //         pt_levels: 4,
+    //         stop_requested: AtomicBool::new(false),
+    //         run_data: None,
+    //     };
+    //     Ok(vm)
+    // }
+    
 
     /// Initializes the VM, creating vCPUs and setting up memory
     pub fn init(&mut self, config: AxVMConfig) -> anyhow::Result<()> {
@@ -47,14 +49,14 @@ impl VmInit {
         let vcpus = self.new_vcpus(&config)?;
 
         let mut run_data = VmStatusRunning::new(
-            VmData::new(self.pt_levels, VM_ASPACE_BASE..VM_ASPACE_END)?,
+            VmRunCommonData::new(self.pt_levels, VM_ASPACE_BASE..VM_ASPACE_END)?,
             vcpus,
         );
 
         debug!("Mapping memory regions for VM {} ({})", self.id, self.name);
         for memory_cfg in &config.memory_regions {
             use crate::vm::MappingFlags;
-            let m = run_data.data.new_memory(
+            let m = run_data.data.try_use()?.new_memory(
                 memory_cfg,
                 MappingFlags::READ
                     | MappingFlags::WRITE
@@ -64,13 +66,13 @@ impl VmInit {
             run_data.data.add_memory(m);
         }
 
-        run_data.data.load_kernel_image(&config)?;
+        run_data.data.try_use()?.load_kernel_image(&config)?;
         run_data.make_dtb(&config)?;
 
-        run_data.data.map_passthrough_regions()?;
+        run_data.data.try_use()?.map_passthrough_regions()?;
 
-        let kernel_entry = run_data.data.kernel_entry();
-        let gpt_root = run_data.data.gpt_root();
+        let kernel_entry = run_data.data.try_use()?.kernel_entry();
+        let gpt_root = run_data.data.try_use()?.gpt_root();
 
         // Setup vCPUs
         for vcpu in &mut run_data.vcpus {
@@ -141,7 +143,7 @@ impl VmInit {
     }
 }
 
-impl VmStatusInitOps for VmInit {
+impl VmStatusInitOps for VmMachineInited {
     type Running = VmStatusRunning;
 
     fn id(&self) -> VmId {
@@ -152,7 +154,7 @@ impl VmStatusInitOps for VmInit {
         &self.name
     }
 
-    fn start(self) -> Result<Self::Running, (anyhow::Error, Self)> {
+    fn start(self, vmdata: VmDataWeak) -> Result<Self::Running, (anyhow::Error, Self)> {
         let mut data = self.run_data.unwrap();
 
         let mut vcpus = vec![];

src/arch/aarch64/vm/mod.rs

@@ -6,37 +6,29 @@ use fdt_edit::{Node, NodeRef, Property, RegInfo};
 use memory_addr::MemoryAddr;
 
 mod init;
+mod unint;
 
 use crate::{
-    GuestPhysAddr, RunError, TASK_STACK_SIZE, Vm, VmData, VmStatusInitOps, VmStatusRunningOps,
-    VmStatusStoppingOps,
+    GuestPhysAddr, RunError, TASK_STACK_SIZE, Vm, VmDataWeak, VmRunCommonData, VmStatusInitOps,
+    VmStatusRunningOps, VmStatusStoppingOps,
     arch::cpu::VCpu,
     config::{AxVMConfig, MemoryKind},
+    data2::VmDataWeak,
     vhal::cpu::CpuHardId,
     vm::{MappingFlags, VmId},
 };
 
-pub use init::VmInit;
+pub(crate) use init::*;
+pub(crate) use unint::*;
 
 const VM_ASPACE_BASE: usize = 0x0;
 const VM_ASPACE_SIZE: usize = 0x7fff_ffff_f000;
 
 impl VmStatusRunningOps for VmStatusRunning {
     type Stopping = VmStatusStopping;
 
-    fn stop(self) -> Result<Self::Stopping, (anyhow::Error, Self)>
-    where
-        Self: Sized,
-    {
-        Ok(VmStatusStopping {})
-    }
-
-    fn do_work(&mut self) -> Result<(), RunError> {
-        if self.vcpu_running_count.load(Ordering::SeqCst) == 0 {
-            Err(RunError::Exit)
-        } else {
-            Ok(())
-        }
+    fn stop(self) -> Self::Stopping {
+        Self::Stopping {}
     }
 }
 
@@ -47,13 +39,13 @@ impl VmStatusStoppingOps for VmStatusStopping {}
 /// Data needed when VM is running
 pub struct VmStatusRunning {
     vcpus: Vec<VCpu>,
-    data: VmData,
+    data: VmDataWeak,
     dtb_addr: GuestPhysAddr,
     vcpu_running_count: Arc<AtomicUsize>,
 }
 
 impl VmStatusRunning {
-    pub(crate) fn new(data: VmData, vcpus: Vec<VCpu>) -> Self {
+    pub(crate) fn new(data: VmDataWeak, vcpus: Vec<VCpu>) -> Self {
         Self {
             vcpus,
             data,
@@ -84,12 +76,12 @@ impl VmStatusRunning {
                 }
             };
 
-            let mut guest_mem = self.data.new_memory(&kind, flags);
+            let mut guest_mem = self.data.try_use()?.new_memory(&kind, flags);
 
             self.dtb_addr = guest_mem.gpa();
 
             guest_mem.copy_from_slice(0, &dtb_cfg.data);
-            self.data.add_reserved_memory(guest_mem);
+            self.data.try_use()?.add_reserved_memory(guest_mem);
         } else {
             debug!(
                 "No dtb provided, generating new dtb for {} ({})",
@@ -127,7 +119,7 @@ impl VmStatusRunning {
             let root_address_cells = fdt.root().address_cells().unwrap_or(2);
             let root_size_cells = fdt.root().size_cells().unwrap_or(2);
 
-            for (i, m) in self.data.memories().iter().enumerate() {
+            for (i, m) in self.data.try_use()?.memories().iter().enumerate() {
                 let mut node = Node::new(&format!("memory@{i}"));
                 let mut prop = Property::new("device_type", vec![]);
                 prop.set_string("memory");
@@ -147,7 +139,7 @@ impl VmStatusRunning {
             let f = fdt_edit::Fdt::from_bytes(&dtb_data).unwrap();
             debug!("Generated DTB:\n{f}");
 
-            let mut guest_mem = self.data.memories().into_iter().next().unwrap();
+            let mut guest_mem = self.data.try_use()?.memories().into_iter().next().unwrap();
             let mut dtb_start =
                 (guest_mem.0.as_usize() + guest_mem.1.min(512 * 1024 * 1024)) - dtb_data.len();
             dtb_start = dtb_start.align_down_4k();
@@ -170,6 +162,8 @@ impl VmStatusRunning {
     fn copy_to_guest(&mut self, gpa: GuestPhysAddr, data: &[u8]) {
         let parts = self
             .data
+            .try_use()
+            .unwrap()
             .addrspace
             .lock()
             .translated_byte_buffer(gpa.as_usize().into(), data.len())