feat: 增强虚拟机管理功能，添加 CPU 启动和运行管理逻辑，清理未使用的代码

Author: ZR233

src/arch/aarch64/cpu.rs

@@ -136,12 +136,18 @@ impl VCpuOp for VCpu {
                 arm_vcpu::AxVCpuExitReason::MmioWrite { addr, width, data } => todo!(),
                 arm_vcpu::AxVCpuExitReason::SysRegRead { addr, reg } => todo!(),
                 arm_vcpu::AxVCpuExitReason::SysRegWrite { addr, value } => todo!(),
-                arm_vcpu::AxVCpuExitReason::ExternalInterrupt => todo!(),
+                arm_vcpu::AxVCpuExitReason::ExternalInterrupt => {
+                    axhal::irq::irq_handler(0);
+                }
                 arm_vcpu::AxVCpuExitReason::CpuUp {
                     target_cpu,
                     entry_point,
                     arg,
-                } => todo!(),
+                } => {
+                    self.vm()?.with_machine_running_mut(|running| {
+                        running.cpu_up(CpuHardId::new(target_cpu as _), entry_point, arg)
+                    })??;
+                }
                 arm_vcpu::AxVCpuExitReason::CpuDown { _state } => todo!(),
                 arm_vcpu::AxVCpuExitReason::SystemDown => {
                     info!("vCPU {} requested system shutdown", self.bind_id());

src/arch/aarch64/vm/inited.rs

@@ -1,7 +1,7 @@
 use std::{string::String, vec::Vec};
 
 use crate::{
-    GuestPhysAddr, VmAddrSpace, VmMachineInitedOps, VmMachineRunningCommon,
+    VmAddrSpace, VmMachineInitedOps, VmMachineRunningCommon,
     arch::{VmMachineRunning, cpu::VCpu},
     data::VmDataWeak,
     vm::VmId,

src/arch/aarch64/vm/running.rs

@@ -1,8 +1,8 @@
 use fdt_edit::NodeRef;
 
 use crate::{
-    VmAddrSpace, VmMachineRunningCommon, VmMachineRunningOps, VmMachineStoppingOps,
-    arch::vm::DevMapConfig,
+    GuestPhysAddr, VmAddrSpace, VmMachineRunningCommon, VmMachineRunningOps, VmMachineStoppingOps,
+    arch::vm::DevMapConfig, vhal::cpu::CpuHardId,
 };
 
 /// Data needed when VM is running
@@ -12,6 +12,24 @@ pub struct VmMachineRunning {
 
 impl VmMachineRunning {
     fn handle_node_regs(dev_vec: &mut [DevMapConfig], node: &NodeRef<'_>) {}
+    pub fn cpu_up(
+        &mut self,
+        target_cpu: CpuHardId,
+        entry_point: GuestPhysAddr,
+        arg: u64,
+    ) -> anyhow::Result<()> {
+        let mut cpu = self
+            .common
+            .cpus
+            .remove(&target_cpu)
+            .ok_or(anyhow!("No cpu {target_cpu} found"))?;
+
+        cpu.vcpu.set_entry(entry_point.as_usize().into()).unwrap();
+        cpu.vcpu.ctx_mut().gpr[0] = arg;
+
+        self.common.run_cpu(cpu)?;
+        Ok(())
+    }
 }
 
 impl VmMachineRunningOps for VmMachineRunning {

src/vhal/cpu.rs

@@ -47,10 +47,6 @@ impl HCpuExclusive {
         panic!("CPU data not found for CPU ID {}", self.0);
     }
 
-    pub fn cpu_id(&self) -> CpuId {
-        self.0
-    }
-
     pub fn hard_id(&self) -> CpuHardId {
         self.with_cpu(|cpu| cpu.hard_id())
     }

src/vm/data.rs

@@ -158,6 +158,38 @@ impl VmData {
             inner: Arc::downgrade(&self.inner),
         }
     }
+
+    pub(crate) fn with_machine_running<F, R>(&self, f: F) -> Result<R, RunError>
+    where
+        F: FnOnce(&VmMachineRunning) -> R,
+    {
+        let status = self.machine.read();
+        let running = match &*status {
+            VmMachineState::Running(running) => running,
+            _ => {
+                return Err(RunError::ExitWithError(anyhow!(
+                    "VM is not in Running state"
+                )));
+            }
+        };
+        Ok(f(running))
+    }
+
+    pub(crate) fn with_machine_running_mut<F, R>(&self, f: F) -> Result<R, RunError>
+    where
+        F: FnOnce(&mut VmMachineRunning) -> R,
+    {
+        let mut status = self.machine.write();
+        let running = match &mut *status {
+            VmMachineState::Running(running) => running,
+            _ => {
+                return Err(RunError::ExitWithError(anyhow!(
+                    "VM is not in Running state"
+                )));
+            }
+        };
+        Ok(f(running))
+    }
 }
 
 impl From<Arc<VmDataInner>> for VmData {
@@ -207,23 +239,6 @@ impl VmDataWeak {
             inner.status.store(VMStatus::Stopped);
         }
     }
-
-    pub(crate) fn with_machine_running<F, R>(&self, f: F) -> Result<R, RunError>
-    where
-        F: FnOnce(&VmMachineRunning) -> R,
-    {
-        let vmdata = self.try_upgrade()?;
-        let status = vmdata.machine.read();
-        let running = match &*status {
-            VmMachineState::Running(running) => running,
-            _ => {
-                return Err(RunError::ExitWithError(anyhow!(
-                    "VM is not in Running state"
-                )));
-            }
-        };
-        Ok(f(running))
-    }
 }
 
 impl Debug for VmDataWeak {

src/vm/machine/mod.rs

@@ -1,4 +1,3 @@
-use alloc::string::String;
 use core::sync::atomic::{AtomicU8, Ordering};
 
 use crate::{
@@ -48,12 +47,6 @@ pub enum VmMachineState {
     Stopped,
 }
 
-impl VmMachineState {
-    pub fn is_active(&self) -> bool {
-        !matches!(self, VmMachineState::Stopping(_) | VmMachineState::Stopped)
-    }
-}
-
 /// Auxiliary wrapper that stores the current machine status in an atomically
 /// readable form so management threads can query it without synchronisation
 /// overhead.

src/vm/machine/running.rs

@@ -8,7 +8,7 @@ use std::{
 use alloc::vec::Vec;
 
 use crate::{
-    RunError, TASK_STACK_SIZE, VmAddrSpace, arch::cpu::VCpu, data::VmDataWeak, vcpu::VCpuOp,
+    TASK_STACK_SIZE, VmAddrSpace, arch::cpu::VCpu, data::VmDataWeak, vcpu::VCpuOp,
     vhal::cpu::CpuHardId,
 };
 
@@ -84,10 +84,6 @@ impl VmMachineRunningCommon {
             vm: self.vm.clone(),
         }
     }
-
-    pub fn vmspace(&self) -> &VmAddrSpace {
-        &self.vmspace
-    }
 }
 
 struct Waiter {