atmos/kernel/

timer.rs

// timer.rs - ARM Generic Timer (Non-Secure Physical Timer CNTP) Driver
#![allow(dead_code)]
use alloc::string::String;
use core::sync::atomic::{AtomicUsize, Ordering};

// `init()`/`init_secondary()` は全4コアそれぞれの CNTP ローカルタイマーを
// 個別に有効化し、各コアの `rust_irq_handler` が自コアのタイマー割り込み
// ごとに `handle_timer_irq()` を呼ぶ（`interrupt.rs` の `int_src` チェックに
// コア限定は無い）。そのため `SYSTEM_TICKS` は最大4コアから並行に
// インクリメントされ得る。かつては非アトミックな `static mut usize` の
// `+= 1` だったため、read-modify-write の競合で更新ロストが起こり得た
// （2026-07-14 発見。`spec/TODO.md`「デバッグ・検証候補」参照。
// `AtomicUsize` 化はこの更新ロストのみを解消するもので、下記の
// レート問題とは別）。
//
// **レート問題（2026-07-14 に追加修正）**: 4コアそれぞれが独立に約10ms
// 周期でカウントアップすると、消費側（`layout.rs` の CSS アニメーション
// 時計・`main.rs` の `ticks==500`/sysmon 間隔判定等）が前提とする
// 「1 tick = 10ms」という設計が崩れ、実質最大4倍速で進んでしまう。
// `handle_timer_irq()` 側で `Core 0` のみがインクリメントするよう
// ガードして解消した。`watchdog::check_from_irq()`
// （`handle_timer_irq()` から全コアで無条件に呼ばれる）はこの
// `SYSTEM_TICKS` を一切参照せず `get_system_time_ms()`（コア数に
// 非依存のカウンタレジスタ直読み）のみを使うため、このガードによる
// 影響は無いことをコードで確認済み。
static SYSTEM_TICKS: AtomicUsize = AtomicUsize::new(0);
static mut TIMER_PERIOD_TICKS: u64 = 0;

// --- 壁時計（NTP で同期した実時刻）---
// NTP 同期時の Unix 時刻（秒, UTC）と、その時点のシステム稼働ミリ秒を保持する。
// `set_wall_clock()` の書き手は `net_service_thread`（Core 2 固定、NTP 同期
// 契機）と Aura の日時設定コマンド（`os_lib/aura/builtins.rs`、Core 0 固定の
// `gui_shell_process` から）の2箇所存在し、読み手（`get_unix_time()` 等、
// UI の時計表示等）は Core 0 から呼ばれる。3変数（Unix秒/基準ms/設定済み
// フラグ）を個別の `static mut` として非アトミックに更新していたため、
// Core 2 が書き込み中に Core 0 が読むと三つ組が不整合な状態
// （例: `WALL_SET=true` が先に見えるが `WALL_BASE_MS` はまだ更新前）で
// 読める可能性があった（2026-07-14 発見。`spec/TODO.md`「デバッグ・
// 検証候補」節の `static mut` SMP 横断監査で確認）。3値をまとめて
// `spin::Mutex` で保護し、読み書きの原子性を保証する。
struct WallClock {
    base_unix: u64,
    base_ms: u64,
    set: bool,
}
static WALL_CLOCK: spin::Mutex<WallClock> = spin::Mutex::new(WallClock {
    base_unix: 0,
    base_ms: 0,
    set: false,
});

/// JST のタイムゾーンオフセット（秒）
const JST_OFFSET_SECS: u64 = 9 * 3600;
/// NTP epoch (1900-01-01) と Unix epoch (1970-01-01) の差（秒）
pub const NTP_UNIX_OFFSET: u64 = 2_208_988_800;

/// ARM Generic Timer を 10ms 間隔で初期化します
pub fn init() {
    unsafe {
        let freq: u64;
        core::arch::asm!("mrs {}, cntfrq_el0", out(reg) freq);
        TIMER_PERIOD_TICKS = freq / 100;
        core::arch::asm!("msr cntp_tval_el0, {}", in(reg) TIMER_PERIOD_TICKS);
        let ctrl: u64 = 1;
        core::arch::asm!("msr cntp_ctl_el0, {}", in(reg) ctrl);
    }
    SYSTEM_TICKS.store(0, Ordering::Relaxed);
    crate::debug!("[TIMER] ARM Generic Timer enabled at 10ms intervals");
}

pub fn init_secondary() {
    unsafe {
        core::arch::asm!("msr cntp_tval_el0, {}", in(reg) TIMER_PERIOD_TICKS);
        let ctrl: u64 = 1;
        core::arch::asm!("msr cntp_ctl_el0, {}", in(reg) ctrl);
    }
}

/// タイマー割り込みハンドラから呼び出され、次の 10ms の割り込みを設定します
pub fn handle_timer_irq() {
    unsafe {
        // 次の 10ms のカウントを設定
        core::arch::asm!("msr cntp_tval_el0, {}", in(reg) TIMER_PERIOD_TICKS);
    }

    // `SYSTEM_TICKS` は「1 tick ≈ 10ms」という消費側の前提を保つため、
    // 常時稼働する Core 0 のローカルタイマー割り込みのみでカウントする
    // （他コアの割り込みでも進めると最大4倍速になってしまうレート問題の
    // 対策。上のコメント参照）。
    if crate::kernel::scheduler::core_id() == 0 {
        SYSTEM_TICKS.fetch_add(1, Ordering::Relaxed);
    }

    // アプリ描画ウォッチドッグ: メインスレッドが draw に張り付いていないか確認（ハング検知）
    // `SYSTEM_TICKS` を参照しないため上記のコアガードとは無関係に全コアで実行する。
    crate::kernel::watchdog::check_from_irq();
}

/// 起動時からのシステムティック（10ms単位）を取得します
pub fn get_ticks() -> usize {
    SYSTEM_TICKS.load(Ordering::Relaxed)
}

/// システムカウンターから現在時刻をマイクロ秒単位で取得します (u128でオーバーフロー防止)
pub fn get_system_time_us() -> u64 {
    let count: u64;
    let freq: u64;
    unsafe {
        core::arch::asm!("mrs {}, cntpct_el0", out(reg) count);
        core::arch::asm!("mrs {}, cntfrq_el0", out(reg) freq);
    }
    ((count as u128 * 1_000_000) / freq as u128) as u64
}

/// システムカウンターから現在時刻をミリ秒単位で取得します
pub fn get_system_time_ms() -> u64 {
    get_system_time_us() / 1000
}

// ---------------------------------------------------------------------------
// 壁時計（NTP 同期した実時刻）
// ---------------------------------------------------------------------------

/// NTP 等で取得した Unix 時刻（UTC 秒）を基準として登録する。
pub fn set_wall_clock(unix_secs: u64) {
    let now_ms = get_system_time_ms();
    let mut w = WALL_CLOCK.lock();
    w.base_unix = unix_secs;
    w.base_ms = now_ms;
    w.set = true;
}

/// 壁時計が同期済みかどうか
pub fn is_wall_clock_set() -> bool {
    WALL_CLOCK.lock().set
}

/// 現在の Unix 時刻（UTC 秒）を返す。未同期なら None。
pub fn get_unix_time() -> Option<u64> {
    let w = WALL_CLOCK.lock();
    if !w.set {
        return None;
    }
    let elapsed_ms = get_system_time_ms().wrapping_sub(w.base_ms);
    Some(w.base_unix + elapsed_ms / 1000)
}

/// 日数（1970-01-01 からの経過日数）を (年, 月, 日) に変換する。
/// Howard Hinnant の civil_from_days アルゴリズム。
fn civil_from_days(z: i64) -> (i64, u32, u32) {
    let z = z + 719468;
    let era = (if z >= 0 { z } else { z - 146096 }) / 146097;
    let doe = z - era * 146097; // [0, 146096]
    let yoe = (doe - doe / 1460 + doe / 36524 - doe / 146096) / 365; // [0, 399]
    let y = yoe + era * 400;
    let doy = doe - (365 * yoe + yoe / 4 - yoe / 100); // [0, 365]
    let mp = (5 * doy + 2) / 153; // [0, 11]
    let d = (doy - (153 * mp + 2) / 5 + 1) as u32; // [1, 31]
    let m = (if mp < 10 { mp + 3 } else { mp - 9 }) as u32; // [1, 12]
    (if m <= 2 { y + 1 } else { y }, m, d)
}

/// 現在の JST 日時を (年, 月, 日, 時, 分, 秒) で返す。未同期なら None。
pub fn get_datetime_jst() -> Option<(i64, u32, u32, u32, u32, u32)> {
    let unix = get_unix_time()?;
    let local = unix + JST_OFFSET_SECS;
    let days = (local / 86400) as i64;
    let secs_of_day = local % 86400;
    let (y, mo, d) = civil_from_days(days);
    let hh = (secs_of_day / 3600) as u32;
    let mm = ((secs_of_day % 3600) / 60) as u32;
    let ss = (secs_of_day % 60) as u32;
    Some((y, mo, d, hh, mm, ss))
}

/// 現在の JST 日時を "YYYY-MM-DD  HH:mm" 形式で返す。未同期なら None。
pub fn format_datetime_jst() -> Option<String> {
    let (y, mo, d, hh, mm, _ss) = get_datetime_jst()?;
    Some(alloc::format!(
        "{:04}-{:02}-{:02}  {:02}:{:02}",
        y,
        mo,
        d,
        hh,
        mm
    ))
}

/// 現在の JST 時刻を "HH:MM:SS" で返す（コマンド実行時刻の記録用）。未同期なら None。
pub fn format_time_hms_jst() -> Option<String> {
    let (_y, _mo, _d, hh, mm, ss) = get_datetime_jst()?;
    Some(alloc::format!("{:02}:{:02}:{:02}", hh, mm, ss))
}