更新 Cargo.toml，添加新的依赖项并调整现有依赖项；重构 vhal 模块，新增定时器功能并移除旧的 vhal 实现

Author: ZR233

Cargo.toml

@@ -15,18 +15,18 @@ anyhow = {version = "1.0", default-features = false}
 cfg-if = "1.0"
 log = "0.4"
 spin = "0.10"
-axhal.workspace = true
-axruntime.workspace = true
+timer_list = "0.1"
 fdt-parser = "0.5"
+lazyinit = "0.2"
 
 # System independent crates provided by ArceOS.
 axerrno = "0.1.0"
 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_multiarch = "0.5"
-# percpu = {version = "0.2.0", features = ["arm-el2"]}
+percpu = {version = "0.2", features = ["arm-el2"]}
 
 # System dependent modules provided by ArceOS-Hypervisor.
 axaddrspace = "0.2"
@@ -35,6 +35,12 @@ axaddrspace = "0.2"
 # axvcpu = "0.1"
 axvmconfig = {version = "0.1", default-features = false}
 
+axhal.workspace = true
+axruntime.workspace = true
+axtask.workspace = true
+
+
+
 [target.'cfg(target_arch = "x86_64")'.dependencies]
 # x86_vcpu = "0.1"
 

src/arch/aarch64/cpu.rs

@@ -11,6 +11,5 @@ struct PreCpu;
 
 pub fn init() -> anyhow::Result<()> {
     PRE_CPU.init();
-    todo!();
     Ok(())
 }

src/lib.rs

@@ -9,26 +9,30 @@
 //! This crate contains:
 //! - [`AxVM`]: The main structure representing a VM.
 
+#[macro_use]
 extern crate alloc;
 #[macro_use]
 extern crate log;
+#[macro_use]
+extern crate anyhow;
+
+const TASK_STACK_SIZE: usize = 0x4000; // 16KB
 
 #[cfg_attr(target_arch = "aarch64", path = "arch/aarch64/mod.rs")]
 #[cfg_attr(target_arch = "x86_64", path = "arch/x86_64/mod.rs")]
 pub mod arch;
 
 mod fdt;
-
 mod vcpu;
 mod vm;
 
 pub mod config;
 pub mod vhal;
 
-use anyhow::bail;
-
 
 pub fn enable_viretualization() -> anyhow::Result<()> {
     vhal::init()?;
+
+    panic!();
     Ok(())
 }

src/vhal.rs

@@ -0,0 +1,112 @@
+use core::{
+    cell::UnsafeCell,
+    sync::atomic::{AtomicUsize, Ordering},
+};
+
+use alloc::{collections::btree_map::BTreeMap, vec::Vec};
+use axtask::AxCpuMask;
+
+use crate::{
+    TASK_STACK_SIZE,
+    arch::{self, Hal},
+};
+
+mod timer;
+
+pub fn init() -> anyhow::Result<()> {
+    Hal::init();
+
+    static CORES: AtomicUsize = AtomicUsize::new(0);
+
+    let cpu_count = cpu_count();
+
+    info!("Initializing VHal for {cpu_count} CPUs...");
+
+    for cpu_id in 0..cpu_count {
+        let _handle = axtask::spawn_raw(
+            move || {
+                info!("Core {cpu_id} is initializing hardware virtualization support...");
+                // Initialize cpu affinity here.
+                assert!(
+                    axtask::set_current_affinity(AxCpuMask::one_shot(cpu_id)),
+                    "Initialize CPU affinity failed!"
+                );
+                info!("Enabling hardware virtualization support on core {cpu_id}");
+                timer::init_percpu();
+
+                let _ = CORES.fetch_add(1, Ordering::Release);
+            },
+            format!("init-cpu-{}", cpu_id),
+            TASK_STACK_SIZE,
+        );
+    }
+    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();
+    }
+
+    info!("All cores have enabled hardware virtualization support.");
+    Ok(())
+}
+
+pub fn cpu_count() -> usize {
+    axruntime::cpu_count()
+}
+
+pub(crate) trait ArchHal {
+    fn init() -> anyhow::Result<()>;
+    fn cpu_list() -> Vec<CpuHardId>;
+    fn current_enable_viretualization() -> anyhow::Result<()>;
+}
+
+pub fn current_enable_viretualization() -> anyhow::Result<()> {
+    Hal::current_enable_viretualization()
+}
+
+pub(crate) struct PreCpuSet<T>(UnsafeCell<BTreeMap<usize, Option<T>>>);
+
+unsafe impl<T> Sync for PreCpuSet<T> {}
+unsafe impl<T> Send for PreCpuSet<T> {}
+
+impl<T> PreCpuSet<T> {
+    pub const fn new() -> Self {
+        PreCpuSet(UnsafeCell::new(BTreeMap::new()))
+    }
+
+    unsafe fn set(&self, cpu_id: usize, val: T) {
+        let pre_cpu_map = unsafe { &mut *self.0.get() };
+        pre_cpu_map.insert(cpu_id, Some(val));
+    }
+
+    pub fn get(&self, cpu_id: usize) -> Option<&T> {
+        let pre_cpu_map = unsafe { &*self.0.get() };
+        let v = pre_cpu_map.get(&cpu_id)?;
+        Some(v.as_ref().expect("init not called"))
+    }
+
+    pub fn init(&self) {
+        let cpu_list = Hal::cpu_list();
+        debug!("Initializing PreCpuSet for CPUs: {:?}", cpu_list);
+        for cpu_id in cpu_list {
+            let v = unsafe { &mut *self.0.get() };
+            v.insert(cpu_id.raw(), None);
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[repr(transparent)]
+pub struct CpuHardId(usize);
+
+impl CpuHardId {
+    pub fn new(id: usize) -> Self {
+        CpuHardId(id)
+    }
+
+    pub fn raw(&self) -> usize {
+        self.0
+    }
+}

src/vhal/mod.rs

@@ -0,0 +1,113 @@
+use core::sync::atomic::AtomicUsize;
+use core::sync::atomic::Ordering;
+
+use axhal;
+
+use alloc::boxed::Box;
+use kspin::SpinNoIrq;
+use lazyinit::LazyInit;
+use timer_list::{TimeValue, TimerEvent, TimerList};
+
+static TOKEN: AtomicUsize = AtomicUsize::new(0);
+// const PERIODIC_INTERVAL_NANOS: u64 = axhal::time::NANOS_PER_SEC / axconfig::TICKS_PER_SEC as u64;
+
+/// Represents a timer event in the virtual machine monitor (VMM).
+///
+/// This struct holds a unique token for the timer and a callback function
+/// that will be executed when the timer expires.
+pub struct VmmTimerEvent {
+    // Unique identifier for the timer event
+    token: usize,
+    // Callback function to be executed when the timer expires
+    timer_callback: Box<dyn FnOnce(TimeValue) + Send + 'static>,
+}
+
+impl VmmTimerEvent {
+    fn new<F>(token: usize, f: F) -> Self
+    where
+        F: FnOnce(TimeValue) + Send + 'static,
+    {
+        Self {
+            token,
+            timer_callback: Box::new(f),
+        }
+    }
+}
+
+impl TimerEvent for VmmTimerEvent {
+    fn callback(self, now: TimeValue) {
+        (self.timer_callback)(now)
+    }
+}
+
+#[percpu::def_percpu]
+static TIMER_LIST: LazyInit<SpinNoIrq<TimerList<VmmTimerEvent>>> = LazyInit::new();
+
+/// Registers a new timer that will execute at the specified deadline
+///
+/// # Arguments
+/// - `deadline`: The absolute time in nanoseconds when the timer should trigger
+/// - `handler`: The callback function to execute when the timer expires
+///
+/// # Returns
+/// A unique token that can be used to cancel this timer later
+pub fn register_timer<F>(deadline: u64, handler: F) -> usize
+where
+    F: FnOnce(TimeValue) + Send + 'static,
+{
+    trace!("Registering timer...");
+    trace!(
+        "deadline is {:#?} = {:#?}",
+        deadline,
+        TimeValue::from_nanos(deadline)
+    );
+    let timer_list = unsafe { TIMER_LIST.current_ref_mut_raw() };
+    let mut timers = timer_list.lock();
+    let token = TOKEN.fetch_add(1, Ordering::Release);
+    let event = VmmTimerEvent::new(token, handler);
+    timers.set(TimeValue::from_nanos(deadline), event);
+    token
+}
+
+/// Cancels a timer with the specified token.
+///
+/// # Parameters
+/// - `token`: The unique token of the timer to cancel.
+pub fn cancel_timer(token: usize) {
+    let timer_list = unsafe { TIMER_LIST.current_ref_mut_raw() };
+    let mut timers = timer_list.lock();
+    timers.cancel(|event| event.token == token);
+}
+
+/// Check and process any pending timer events
+pub fn check_events() {
+    // info!("Checking timer events...");
+    // info!("now is {:#?}", axhal::time::wall_time());
+    let timer_list = unsafe { TIMER_LIST.current_ref_mut_raw() };
+    loop {
+        let now = axhal::time::wall_time();
+        let event = timer_list.lock().expire_one(now);
+        if let Some((_deadline, event)) = event {
+            trace!("pick one {_deadline:#?} to handle!!!");
+            event.callback(now);
+        } else {
+            break;
+        }
+    }
+}
+
+// /// Schedule the next timer event based on the periodic interval
+// pub fn scheduler_next_event() {
+//     trace!("Scheduling next event...");
+//     let now_ns = axhal::time::monotonic_time_nanos();
+//     let deadline = now_ns + PERIODIC_INTERVAL_NANOS;
+//     debug!("PHY deadline {} !!!", deadline);
+//     axhal::time::set_oneshot_timer(deadline);
+// }
+
+/// Initialize the hypervisor timer system
+pub fn init_percpu() {
+    info!("Initing HV Timer...");
+    let timer_list = unsafe { TIMER_LIST.current_ref_mut_raw() };
+    timer_list.init_once(SpinNoIrq::new(TimerList::new()));
+}