feat: refactor timer mechanism and bump to 0.4.0 (#15)

Author: yfblock

Cargo.lock

@@ -9,18 +9,18 @@ members = [
 ]
 
 [workspace.package]
-version = "0.3.2"
+version = "0.4.0"
 edition = "2021"
 description = "This crate provides the interface for multiple platforms."
 authors = ["yfblock@321353225@qq.com"]
 license = "MIT"
 repository = "https://github.com/Byte-OS/polyhal"
 
 [workspace.dependencies]
-polyhal = { version = "0.3.2" }
-polyhal-boot = { version = "0.3.2" }
-polyhal-macro = { version = "0.3.2" }
-polyhal-trap = { version = "0.3.2" }
+polyhal = { version = "0.4.0" }
+polyhal-boot = { version = "0.4.0" }
+polyhal-macro = { version = "0.4.0" }
+polyhal-trap = { version = "0.4.0" }
 
 bitflags = "2.9.0"
 cfg-if = "1.0.0"

Cargo.toml

@@ -4,11 +4,15 @@
 mod allocator;
 mod frame;
 mod pci;
+use core::hint::spin_loop;
 use core::panic::PanicInfo;
+use core::time::Duration;
 
 use frame::frame_alloc;
+use polyhal::irq::IRQ;
 use polyhal::mem::{get_fdt, get_mem_areas};
 use polyhal::percpu::get_local_thread_pointer;
+use polyhal::timer::{self, current_time};
 use polyhal::{
     common::PageAlloc,
     instruction::{ebreak, shutdown},
@@ -31,6 +35,9 @@ impl PageAlloc for PageAllocImpl {
     }
 }
 
+#[percpu]
+static mut TIMER_TICKS: usize = 0;
+
 /// kernel interrupt
 #[polyhal::arch_interrupt]
 fn kernel_interrupt(ctx: &mut TrapFrame, trap_type: TrapType) {
@@ -51,7 +58,10 @@ fn kernel_interrupt(ctx: &mut TrapFrame, trap_type: TrapType) {
             log::info!("illegal instruction");
         }
         Timer => {
-            log::info!("Timer");
+            TIMER_TICKS.with_mut(|ticks| *ticks += 1);
+            let next = current_time() + Duration::from_millis(100);
+            timer::set_next_timer(next);
+            log::info!("Timer: {:#x?}  next: {:#x?}", TIMER_TICKS.read(), next);
         }
         _ => {
             log::warn!("unsuspended trap type: {:?}", trap_type);
@@ -87,8 +97,18 @@ fn main(hartid: usize) {
 
     // Test BreakPoint Interrupt
     ebreak();
-
     crate::pci::init();
+
+    log::info!("Waiting for TIMER_TICKS greater than 5");
+    IRQ::int_enable();
+    let target = current_time() + Duration::from_millis(1);
+    timer::set_next_timer(target);
+    log::info!("current: {:#x?} target: {:#x?}", current_time(), target);
+
+    while *TIMER_TICKS <= 5 {
+        spin_loop();
+    }
+
     log::info!("Run END. Shutdown successfully.");
     shutdown();
 }

example/src/main.rs

@@ -5,7 +5,6 @@ use tock_registers::interfaces::Readable;
 
 use crate::trapframe::TrapFrame;
 use polyhal::irq::{get_irq, TIMER_IRQ_NUM};
-use polyhal::timer::set_next_timer;
 
 use super::{EscapeReason, TrapType};
 
@@ -38,7 +37,6 @@ fn handle_exception(tf: &mut TrapFrame, kind: TrapKind, source: TrapSource) -> T
         let trap_type = match irq.irq_num() {
             TIMER_IRQ_NUM => {
                 irq.ack();
-                set_next_timer();
                 TrapType::Timer
             }
             _ => TrapType::Irq(irq),

polyhal-trap/src/trap/aarch64.rs

@@ -4,7 +4,7 @@ mod macros;
 use super::{EscapeReason, TrapType};
 use crate::trapframe::TrapFrame;
 use core::arch::naked_asm;
-use polyhal::{consts::VIRT_ADDR_START, timer};
+use polyhal::consts::VIRT_ADDR_START;
 use riscv::{
     interrupt::{Exception, Interrupt},
     register::{
@@ -47,10 +47,7 @@ fn kernel_callback(context: &mut TrapFrame) -> TrapType {
         }
         Trap::Exception(Exception::UserEnvCall) => TrapType::SysCall,
         // 时钟中断
-        Trap::Interrupt(Interrupt::SupervisorTimer) => {
-            timer::set_next_timeout();
-            TrapType::Timer
-        }
+        Trap::Interrupt(Interrupt::SupervisorTimer) => TrapType::Timer,
         Trap::Exception(Exception::StorePageFault) => TrapType::StorePageFault(stval),
         Trap::Exception(Exception::StoreFault) => TrapType::StorePageFault(stval),
         Trap::Exception(Exception::InstructionPageFault) => TrapType::InstructionPageFault(stval),

polyhal-trap/src/trap/riscv64.rs

@@ -26,24 +26,6 @@ static mut LOCAL_APIC: Option<LocalApic> = None;
 static mut IS_X2APIC: bool = false;
 static IO_APIC: Once<MutexNoIrq<IoApic>> = Once::new();
 
-/// Registers an IRQ handler for the given IRQ.
-///
-/// It also enables the IRQ if the registration succeeds. It returns `false` if
-/// the registration failed.
-// pub fn register_handler(vector: usize, handler: crate::irq::IrqHandler) -> bool {
-//     crate::irq::register_handler_common(vector, handler)
-// }
-
-/// Dispatches the IRQ.
-///
-/// This function is called by the common interrupt handler. It looks
-/// up in the IRQ handler table and calls the corresponding handler. If
-/// necessary, it also acknowledges the interrupt controller after handling.
-// pub fn dispatch_irq(vector: usize) {
-//     crate::irq::dispatch_irq_common(vector);
-//     unsafe { local_apic().end_of_interrupt() };
-// }
-
 pub fn local_apic<'a>() -> &'a mut LocalApic {
     // It's safe as LAPIC is per-cpu.
     unsafe { LOCAL_APIC.as_mut().unwrap() }

polyhal/src/arch/x86_64/apic.rs

@@ -3,6 +3,7 @@ use arm_gicv2::{translate_irq, InterruptType};
 use arm_gicv2::{GicCpuInterface, GicDistributor};
 
 use crate::components::irq::{IRQVector, IRQ};
+use crate::ctor::CtorType;
 use crate::utils::MutexNoIrq;
 use crate::PhysAddr;
 
@@ -87,3 +88,5 @@ impl IRQ {
         DAIF.read(DAIF::I) == 0
     }
 }
+
+ph_ctor!(AARCH64_INIT_GIC, CtorType::Cpu, init);

polyhal/src/components/irq/aarch64.rs

@@ -1,26 +1,48 @@
+use core::time::Duration;
+
 use aarch64_cpu::registers::{CNTFRQ_EL0, CNTPCT_EL0, CNTP_CTL_EL0, CNTP_TVAL_EL0};
 use tock_registers::interfaces::{Readable, Writeable};
 
-use crate::{
-    components::irq::{IRQ, TIMER_IRQ_NUM},
-    time::Time,
-};
+use crate::components::irq::{IRQ, TIMER_IRQ_NUM};
 
-impl Time {
-    #[inline]
-    pub fn get_freq() -> usize {
-        CNTFRQ_EL0.get() as _
-    }
+use super::current_time;
 
-    /// Returns the current clock time in hardware ticks.
-    #[inline]
-    pub fn now() -> Self {
-        Self(CNTPCT_EL0.get() as _)
-    }
+/// Get ticks from system clock
+///
+/// # Return
+///
+/// - [u64] clock ticks
+#[inline]
+pub fn get_ticks() -> u64 {
+    CNTPCT_EL0.get()
 }
 
-pub fn set_next_timer() {
-    CNTP_TVAL_EL0.set(CNTFRQ_EL0.get() / 1000);
+/// Get frequency of the system clock
+///
+/// # Return
+///
+/// - [u64] n ticks per second
+#[inline]
+pub fn get_freq() -> u64 {
+    CNTFRQ_EL0.get()
+}
+
+/// Set the next timer
+///
+/// # parameters
+///
+/// - next [Duration] next time from system boot
+#[inline]
+pub fn set_next_timer(next: Duration) {
+    let curr = current_time();
+    if next < curr {
+        return;
+    }
+    let interval = next - curr;
+    CNTP_TVAL_EL0.set(
+        interval.as_secs() * get_freq()
+            + interval.subsec_nanos() as u64 * get_freq() / 1_000_000_000,
+    );
 }
 
 pub fn init() {
@@ -30,5 +52,5 @@ pub fn init() {
     CNTP_TVAL_EL0.set(0);
     // Enable the timer irq.
     IRQ::irq_enable(TIMER_IRQ_NUM);
-    set_next_timer();
+    set_next_timer(Duration::ZERO);
 }

polyhal/src/components/timer/aarch64.rs

@@ -1,29 +1,57 @@
+use core::time::Duration;
+
 use loongArch64::register::ecfg::{self, LineBasedInterrupt};
 use loongArch64::register::tcfg;
 /// Returns the current clock time in hardware ticks.
 use loongArch64::time::{get_timer_freq, Time};
 use spin::Lazy;
 
+use crate::timer::current_time;
+
 // static mut FREQ: usize = 0;
-static FREQ: Lazy<usize> = Lazy::new(|| get_timer_freq());
+static FREQ: Lazy<u64> = Lazy::new(|| get_timer_freq() as _);
 
-impl crate::time::Time {
-    #[inline]
-    pub fn get_freq() -> usize {
-        *FREQ
-    }
+/// Get ticks from system clock
+///
+/// # Return
+///
+/// - [u64] clock ticks
+#[inline]
+pub fn get_ticks() -> u64 {
+    Time::read() as _
+}
+
+/// Get frequency of the system clock
+///
+/// # Return
+///
+/// - [u64] n ticks per second
+#[inline]
+pub fn get_freq() -> u64 {
+    *FREQ
+}
 
-    /// Returns the current clock time in hardware ticks.
-    #[inline]
-    pub fn now() -> Self {
-        Self(Time::read())
+/// Set the next timer
+///
+/// # parameters
+///
+/// - next [Duration] next time from system boot#[inline]
+pub fn set_next_timer(next: Duration) {
+    let curr = current_time();
+    if next < curr {
+        return;
     }
+    let interval = next - curr;
+    tcfg::set_init_val(
+        (interval.as_secs() * get_freq()
+            + interval.subsec_nanos() as u64 * get_freq() / 1_000_000_000) as _,
+    );
+    tcfg::set_en(true);
 }
 
 pub fn init() {
-    let ticks = ((*FREQ / 1000) + 3) & !3;
-    tcfg::set_periodic(true); // set timer to one-shot mode
-    tcfg::set_init_val(ticks); // set timer initial value
+    tcfg::set_periodic(false); // set timer to one-shot mode
+    tcfg::set_init_val(0); // set timer initial value
     tcfg::set_en(true); // enable timer
 
     let inter = LineBasedInterrupt::TIMER

polyhal/src/components/timer/loongarch64.rs

@@ -4,7 +4,7 @@
 
 use core::time::Duration;
 
-use crate::{ctor::CtorType, Time};
+use crate::ctor::CtorType;
 
 super::define_arch_mods!();
 
@@ -15,7 +15,9 @@ super::define_arch_mods!();
 /// Return [Duration] with current time
 #[inline]
 pub fn current_time() -> Duration {
-    Duration::from_nanos(Time::now().raw() as _)
+    let ticks = get_ticks();
+    let freq = get_freq();
+    Duration::new(ticks / freq, ((ticks % freq) * 1_000_000_000 / freq) as u32)
 }
 
 ph_ctor!(ARCH_INIT_TIMER, CtorType::Platform, init);