Next2

Cargo.toml

@@ -1,40 +1,62 @@
 [package]
+edition = "2024"
 name = "axvm"
 version = "0.1.0"
-edition = "2024"
 
 [features]
 default = ["vmx"]
 vmx = []
-4-level-ept = ["arm_vcpu/4-level-ept"]   # TODO: Realize 4-level-ept on x86_64 and riscv64.
+# Note: 4-level-ept support is now provided through dynamic page table selection in axaddrspace
+# The feature gate is no longer needed
 
 [dependencies]
-log = "0.4"
+anyhow = {version = "1.0", default-features = false}
 cfg-if = "1.0"
-spin = "0.9"
+lazyinit = "0.2"
+log = "0.4"
+ranges-ext.workspace = true
+spin = "0.10"
+thiserror = {version = "2", default-features = false}
+timer_list = "0.1"
 
 # System independent crates provided by ArceOS.
 axerrno = "0.1.0"
+bitmap-allocator = "0.2.1"
 cpumask = "0.1.0"
-# kspin = "0.1.0"
+kspin = "0.1"
 memory_addr = "0.4"
-page_table_entry = { version = "0.5", features = ["arm-el2"] }
+page_table_entry = {version = "0.5", features = ["arm-el2"]}
 page_table_multiarch = "0.5"
-percpu = { version = "0.2.0", features = ["arm-el2"] }
+percpu = {version = "0.2", features = ["arm-el2"]}
+vm-allocator.workspace = true
 
 # System dependent modules provided by ArceOS-Hypervisor.
-axvcpu = "0.1"
-axaddrspace = "0.1"
-axdevice = { git = "https://github.com/arceos-hypervisor/axdevice.git" }
-axdevice_base = "0.1"
-axvmconfig = { version = "0.1", default-features = false }
+axaddrspace = "0.2"
+# axdevice = {git = "https://github.com/arceos-hypervisor/axdevice.git"}
+# axdevice_base = "0.1"
+# axvcpu = "0.1"
+axhal.workspace = true
+axruntime.workspace = true
+axstd.workspace = true
+axvm-types.workspace = true
+axvmconfig = {version = "0.1", default-features = false}
+fdt-edit = "0.1"
 
 [target.'cfg(target_arch = "x86_64")'.dependencies]
+raw-cpuid = "11"
 x86_vcpu = "0.1"
+axplat-x86-qemu-q35.workspace = true
 
 [target.'cfg(target_arch = "riscv64")'.dependencies]
-riscv_vcpu = "0.1"
+# riscv_vcpu = "0.1"
 
 [target.'cfg(target_arch = "aarch64")'.dependencies]
+aarch64-cpu = "11.0"
+aarch64-cpu-ext = "0.1"
 arm_vcpu = "0.1"
-arm_vgic = { version = "0.1", features = ["vgicv3"] }
+# arm_vgic = {version = "0.1", features = ["vgicv3"]}
+
+[patch.crates-io]
+arm_vcpu = {git = "https://github.com/arceos-hypervisor/arm_vcpu", branch = "next"}
+axvcpu = {git = "https://github.com/arceos-hypervisor/axvcpu.git", branch = "next"}
+axvmconfig = {git = "https://github.com/arceos-hypervisor/axvmconfig.git", branch = "next"}

src/arch/aarch64/cpu.rs

@@ -0,0 +1,209 @@
+use core::{
+    fmt::{self, Debug, Display},
+    ops::Deref,
+};
+
+use aarch64_cpu::registers::*;
+use arm_vcpu::{Aarch64PerCpu, Aarch64VCpuCreateConfig};
+use axvm_types::addr::*;
+
+use crate::{
+    RunError,
+    data::VmDataWeak,
+    vcpu::{VCpuCommon, VCpuOp},
+    vhal::{
+        ArchCpuData,
+        cpu::{CpuHardId, CpuId},
+    },
+};
+
+pub struct HCpu {
+    pub id: CpuId,
+    pub hard_id: CpuHardId,
+    vpercpu: Aarch64PerCpu,
+    max_guest_page_table_levels: usize,
+    pub pa_range: core::ops::Range<usize>,
+    pub pa_bits: usize,
+}
+
+impl HCpu {
+    pub fn new(id: CpuId) -> Self {
+        let mpidr = MPIDR_EL1.get() as usize;
+        let hard_id = mpidr & 0xff_ff_ff;
+
+        let vpercpu = Aarch64PerCpu::new();
+
+        HCpu {
+            id,
+            hard_id: CpuHardId::new(hard_id),
+            vpercpu,
+            max_guest_page_table_levels: 0,
+            pa_range: 0..0,
+            pa_bits: 0,
+        }
+    }
+
+    pub fn init(&mut self) -> anyhow::Result<()> {
+        self.vpercpu.hardware_enable();
+        self.max_guest_page_table_levels = self.vpercpu.max_guest_page_table_levels();
+        self.pa_range = self.vpercpu.pa_range();
+        self.pa_bits = self.vpercpu.pa_bits();
+        Ok(())
+    }
+
+    pub fn max_guest_page_table_levels(&self) -> usize {
+        self.max_guest_page_table_levels
+    }
+}
+
+impl ArchCpuData for HCpu {
+    fn hard_id(&self) -> CpuHardId {
+        self.hard_id
+    }
+}
+
+impl Display for HCpu {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(
+            f,
+            "
+CPU {}:
+  Hard ID: {}
+  PT Levels: {}",
+            self.id, self.hard_id, self.max_guest_page_table_levels
+        )
+    }
+}
+
+pub(super) struct VCpuHal;
+
+impl arm_vcpu::CpuHal for VCpuHal {
+    fn irq_hanlder(&self) {
+        axhal::irq::irq_handler(0);
+    }
+
+    fn inject_interrupt(&self, irq: usize) {
+        todo!()
+    }
+}
+
+pub struct VCpu {
+    pub vcpu: arm_vcpu::Aarch64VCpu,
+    common: VCpuCommon,
+}
+
+impl VCpu {
+    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 = 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 { vcpu, common })
+    }
+
+    pub fn set_pt_level(&mut self, level: usize) {
+        self.vcpu.pt_level = level;
+    }
+
+    pub fn set_pa_bits(&mut self, pa_bits: usize) {
+        self.vcpu.pa_bits = pa_bits;
+    }
+}
+
+impl VCpuOp for VCpu {
+    fn bind_id(&self) -> CpuId {
+        self.common.bind_id()
+    }
+
+    fn hard_id(&self) -> CpuHardId {
+        self.common.hard_id()
+    }
+
+    fn run(&mut self) -> Result<(), RunError> {
+        info!("Starting vCPU {}", self.bind_id());
+
+        self.vcpu
+            .setup_current_cpu(self.vm_id().into())
+            .map_err(|e| anyhow!("{e}"))?;
+        while self.is_active() {
+            debug!("vCPU {} entering guest", self.bind_id());
+            let exit_reason = self.vcpu.run().map_err(|e| anyhow!("{e}"))?;
+            debug!(
+                "vCPU {} exited with reason: {:?}",
+                self.bind_id(),
+                exit_reason
+            );
+            match exit_reason {
+                arm_vcpu::AxVCpuExitReason::Hypercall { nr, args } => todo!(),
+                arm_vcpu::AxVCpuExitReason::MmioRead {
+                    addr,
+                    width,
+                    reg,
+                    reg_width,
+                    signed_ext,
+                } => todo!(),
+                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 => {
+                    axhal::irq::irq_handler(0);
+                }
+                arm_vcpu::AxVCpuExitReason::CpuUp {
+                    target_cpu,
+                    entry_point,
+                    arg,
+                } => {
+                    debug!("vCPU {} requested CPU {} up", self.bind_id(), target_cpu);
+                    self.vm()?.with_machine_running_mut(|running| {
+                        debug!("vCPU {} is bringing up CPU {}", self.bind_id(), target_cpu);
+                        running.cpu_up(CpuHardId::new(target_cpu as _), entry_point, arg)
+                    })??;
+                    self.vcpu.set_gpr(0, 0);
+                }
+                arm_vcpu::AxVCpuExitReason::CpuDown { _state } => todo!(),
+                arm_vcpu::AxVCpuExitReason::SystemDown => {
+                    info!("vCPU {} requested system shutdown", self.bind_id());
+                    self.vm()?.stop()?;
+                }
+                arm_vcpu::AxVCpuExitReason::Nothing => {}
+                arm_vcpu::AxVCpuExitReason::SendIPI {
+                    target_cpu,
+                    target_cpu_aux,
+                    send_to_all,
+                    send_to_self,
+                    vector,
+                } => todo!(),
+                _ => todo!(),
+            }
+        }
+
+        Ok(())
+    }
+}
+
+impl Deref for VCpu {
+    type Target = VCpuCommon;
+
+    fn deref(&self) -> &Self::Target {
+        &self.common
+    }
+}
+
+impl Debug for VCpu {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("VCpu")
+            .field("bind_id", &self.bind_id())
+            .field("hard_id", &self.hard_id())
+            .field("vcpu", &self.vcpu)
+            .finish()
+    }
+}

src/arch/aarch64/hal.rs

@@ -0,0 +1,47 @@
+use alloc::vec::Vec;
+
+use aarch64_cpu::registers::*;
+use aarch64_cpu_ext::cache::{CacheOp, dcache_range};
+
+use crate::fdt;
+use crate::vhal::{
+    ArchHal,
+    cpu::{CpuHardId, CpuId},
+};
+
+use super::cpu::{HCpu, VCpuHal};
+
+pub struct Hal;
+
+impl ArchHal for Hal {
+    fn current_cpu_init(id: CpuId) -> anyhow::Result<HCpu> {
+        info!("Enabling virtualization on cpu {id}");
+        let mut cpu = HCpu::new(id);
+        cpu.init()?;
+        info!("{cpu}");
+        Ok(cpu)
+    }
+
+    fn init() -> anyhow::Result<()> {
+        arm_vcpu::init_hal(&VCpuHal);
+
+        Ok(())
+    }
+
+    fn cpu_list() -> Vec<CpuHardId> {
+        fdt::cpu_list()
+            .unwrap()
+            .into_iter()
+            .map(CpuHardId::new)
+            .collect()
+    }
+
+    fn cpu_hard_id() -> CpuHardId {
+        let mpidr = MPIDR_EL1.get() as usize;
+        CpuHardId::new(mpidr)
+    }
+
+    fn cache_flush(vaddr: arm_vcpu::HostVirtAddr, size: usize) {
+        dcache_range(CacheOp::CleanAndInvalidate, vaddr.as_usize(), size);
+    }
+}

src/arch/aarch64/mod.rs

@@ -0,0 +1,7 @@
+pub mod cpu;
+mod hal;
+mod vm;
+
+pub use cpu::HCpu;
+pub use hal::Hal;
+pub use vm::*;

src/arch/aarch64/vm/inited.rs

@@ -0,0 +1,43 @@
+use std::{string::String, vec::Vec};
+
+use crate::{
+    VmAddrSpace, VmMachineInitedOps, VmMachineRunningCommon,
+    arch::{VmMachineRunning, cpu::VCpu},
+    data::VmDataWeak,
+    vm::VmId,
+};
+
+pub struct VmMachineInited {
+    pub id: VmId,
+    pub name: String,
+    pub vcpus: Vec<VCpu>,
+    pub vmspace: VmAddrSpace,
+}
+
+impl VmMachineInited {}
+
+impl VmMachineInitedOps for VmMachineInited {
+    type Running = VmMachineRunning;
+
+    fn id(&self) -> VmId {
+        self.id
+    }
+
+    fn name(&self) -> &str {
+        &self.name
+    }
+
+    fn start(self, vmdata: VmDataWeak) -> Result<Self::Running, anyhow::Error> {
+        debug!("Starting VM {} ({})", self.id, self.name);
+        let mut running = VmMachineRunning {
+            common: VmMachineRunningCommon::new(self.vmspace, self.vcpus, vmdata),
+        };
+
+        let main = running.common.take_cpu()?;
+
+        running.common.run_cpu(main)?;
+
+        info!("VM {} ({}) main cpu started.", self.id, self.name,);
+        Ok(running)
+    }
+}