atmos/

main.rs

#![cfg_attr(not(test), no_std)]
#![cfg_attr(not(test), no_main)]
#![allow(dead_code)]
#![allow(static_mut_refs)]
// ベアメタル OS 特有の意図的スタイル。以下は「修正」がかえって安全性・可読性を損なうため許可する:
// - needless_range_loop: ハードウェア/カーネルの `static mut` 配列（RUNQUEUES/TCP_SOCKETS/
//   ARP_CACHE 等）への添字ループ。イテレータ化は `&mut` 借用の衝突や unsafe を増やす。
// - too_many_arguments: 描画/レイアウト系の座標・色を取る関数（draw_string(x,y,...,color,size) 等）。
// - type_complexity: JS エンジンの共有キュー（`Rc<RefCell<VecDeque<..>>>`）等の素直な型。
#![allow(clippy::needless_range_loop)]
#![allow(clippy::too_many_arguments)]
#![allow(clippy::type_complexity)]
// 過去 2 回のカーネルパニックは「&str をバイト境界でスライスして UTF-8 文字の途中で panic」が
// 原因だった（TECHNOTE 参照）。クレート全体で &str のバイト境界スライスを禁止し、位置は
// find()/strip_prefix()（ASCII ニードル）由来か str::get（境界違反で None）で安全に扱う。
// 添字が必要な低レベル処理は &[u8] に対して行う（このリントは &str のみ対象）。
#![deny(clippy::string_slice)]

extern crate alloc;

use core::arch::global_asm;
use core::panic::PanicInfo;

// スタートアップアセンブリ boot.S を統合する
#[cfg(not(test))]
global_asm!(include_str!("kernel/boot.S"));

#[macro_use]
pub mod kernel;
pub mod apps;
pub mod os_lib;

use kernel::draw::Screen;
use kernel::mailbox::{FrameBufferRequest, Mailbox};
use kernel::uart::Uart;

// --------------------------------------------------------------------
// 2段階キーリピート設定 ＆ 状態変数
// --------------------------------------------------------------------
pub const AUTO_TEST_BROWSER: bool = true; // 自動テスト用フラグ

// グローバルなシステム状態
pub struct SystemState {
    pub tick: u64,
}

pub struct KeyRepeatParams {
    pub first_delay_ms: u32,
    pub first_interval_ms: u32,
    pub second_repeat_count: u32,
    pub second_delay_ms: u32,
    pub second_interval_ms: u32,
}

pub static mut REPEAT_PARAMS: KeyRepeatParams = KeyRepeatParams {
    first_delay_ms: 200,
    first_interval_ms: 15,
    second_repeat_count: 25,
    second_delay_ms: 10000,
    second_interval_ms: 30,
};

struct KeyRepeatState {
    active_keycode: u8,
    press_start_ms: u64,
    last_repeat_ms: u64,
    stage: u8, // 0: なし, 1: 第一リピート, 2: 第二リピート
}

static mut REPEAT_STATE: KeyRepeatState = KeyRepeatState {
    active_keycode: 0,
    press_start_ms: 0,
    last_repeat_ms: 0,
    stage: 0,
};

// 共有スクリーンオブジェクト
pub static mut CURRENT_SCREEN: Option<Screen> = None;

extern "C" {
    static exception_vector_table: u8;
    static __bss_end: u8;
    static __cpu_stacks_end: u8;
    static mut __cpu_stacks_start: u64;

    static mut spin_cpu1: u64;
    static mut spin_cpu2: u64;
    static mut spin_cpu3: u64;

    fn secondary_entry();
}

/// コア0スタックの番兵値（`decompress_brotli`の旧64KBスタック配列がスタック
/// オーバーフローを起こしブート全体を無音でフリーズさせていた事故（2026-07-23
/// 発見・修正）を踏まえた再発防止策）。ハードウェアのガードページ（MMUで
/// 未マップにする方式）は改修範囲が大きいため、まずソフトウェア側の番兵チェック
/// で「検知だけでもできる」状態にする。コア0のスタックは`link.ld`の
/// `__cpu_stacks_start`（下端、下方向に伸びるスタックが溢れた場合に最初に
/// 踏み潰す場所）から`__stack_cpu0_top`（上端、64KB）まで。ここへ既知の
/// マジック値を書き込んでおき、スタックを多用する処理（起動時セルフテスト等）
/// の前後で`check_stack_canary()`を呼んで破壊されていないか確認する。
const STACK_CANARY_MAGIC: u64 = 0xDEAD_BEEF_CAFE_BABE;

/// コア0スタック下端に番兵値を書き込む。BSSクリア後・スタックを多用する処理
/// より前に一度だけ呼ぶこと。
unsafe fn write_stack_canary() {
    let ptr = core::ptr::addr_of_mut!(__cpu_stacks_start);
    core::ptr::write_volatile(ptr, STACK_CANARY_MAGIC);
}

/// コア0スタック下端の番兵値が破壊されていないか確認する。破壊されていれば
/// （＝スタックオーバーフローでコア0スタック下端を踏み越えた可能性が高い）
/// `false`を返す。呼び出し側は既存の`KERNEL PANIC`と同じ書式で明確に報告し、
/// 原因調査が「ビルドごとに再現性が変わる謎のハング」に逆戻りしないようにする。
unsafe fn check_stack_canary() -> bool {
    let ptr = core::ptr::addr_of!(__cpu_stacks_start);
    core::ptr::read_volatile(ptr) == STACK_CANARY_MAGIC
}

/// `check_stack_canary()`がfalseを返した際に呼ぶ、`rust_el1_sync_handler`
/// （`kernel/syscall.rs`）と同じ書式の明確な報告。ハードウェア例外を伴わない
/// （未マップ領域への到達ではなく隣接する有効なBSS領域を静かに破壊する）
/// タイプのスタックオーバーフローのため、既存のEL1例外ハンドラでは検出
/// できない。パニックはさせず（既に一部破壊されている可能性はあるが、
/// 停止せず継続した方がシリアルログを最後まで残せて調査しやすいため）、
/// 目立つ警告ログのみを出す。
fn report_stack_canary_violation(context: &str) {
    println!("==================================================");
    println!("!!! STACK OVERFLOW DETECTED (software canary) !!!");
    println!("==================================================");
    println!("  Context: {}", context);
    println!(
        "  Core0 stack base (__cpu_stacks_start) canary value was overwritten."
    );
    println!(
        "  Expected: 0x{:016x}",
        STACK_CANARY_MAGIC
    );
    println!(
        "  This means some function used more than 64KB of stack and silently"
    );
    println!(
        "  corrupted adjacent .bss memory (no MMU guard page here yet)."
    );
    println!("==================================================");
}

#[no_mangle]
pub extern "C" fn kmain() -> ! {
    // 1. UARTの初期化
    Uart::init();
    // スタックオーバーフロー検知用の番兵をコア0スタック下端へ書き込む
    // （BSSクリア直後・スタックを多用する処理より前）。
    unsafe {
        write_stack_canary();
    }
    println!("==================================================");
    println!("   AtmOS v3 (ARM64 / OS Base) starting...");
    println!(
        "   Version: {} (Git: {})",
        crate::kernel::fs::BUILD_VERSION,
        crate::kernel::fs::BUILD_GIT_HASH
    );
    println!("   Build Time: {}", crate::kernel::fs::BUILD_TIME);
    println!("   Author: SUGIMURA Hiroshi (Sugimura Laboratory)");
    println!("==================================================");
    crate::warn!(
        "[SYS] Build v{} git:{} {}",
        crate::kernel::fs::BUILD_VERSION,
        crate::kernel::fs::BUILD_GIT_HASH,
        crate::kernel::fs::BUILD_TIME
    );

    // 2. GPUにフレームバッファ（画面）の初期化を要求 (MMU/キャッシュ有効化前に実行することで不整合を回避)
    // 実機ではモニタがサポートしない解像度を要求すると Mailbox が失敗するため、
    // 複数の解像度で順番にフォールバックを試みる
    crate::info!("[GPU] Attempting FrameBuffer allocation with fallback resolutions...");
    let resolutions: [(u32, u32); 5] = [
        (1024, 600), // 7インチ HDMI パネル等のネイティブ解像度を最優先
        (1280, 720),
        (1920, 1080),
        (1024, 768),
        (640, 480),
    ];

    let mut fb_info = None;
    for &(w, h) in resolutions.iter() {
        crate::debug!("[GPU] Trying {}x{}...", w, h);
        let mut mbox_req = FrameBufferRequest::new(w, h);
        let buf_ptr = &mut mbox_req as *mut FrameBufferRequest as *mut u32;
        let buf_slice = unsafe { core::slice::from_raw_parts_mut(buf_ptr, 32) };

        // 実機では D-Cache と GPU 間のコヒーレンシが保証されないため、
        // Mailbox バッファをフラッシュしてからGPUに送信する
        unsafe {
            let addr = buf_slice.as_ptr() as usize;
            let size = buf_slice.len() * 4;
            let cache_line = 64usize;
            let start = addr & !(cache_line - 1);
            let end = addr + size;
            let mut cur = start;
            while cur < end {
                core::arch::asm!("dc civac, {}", in(reg) cur, options(nostack));
                cur += cache_line;
            }
            core::arch::asm!("dsb sy", options(nostack));
        }

        if Mailbox::call(buf_slice, kernel::mailbox::MBOX_CH_PROP).is_ok() {
            if let Some(info) = mbox_req.get_info() {
                let fb_addr = info.pointer as usize;
                // 境界は `mmu.rs` が権威（マップを決めている側）。
                let uncached = fb_addr >= kernel::mmu::DEVICE_REGION_START;
                crate::info!(
                    "[GPU] FrameBuffer OK: {}x{} pitch={} vptr={:?} vh={} size={}",
                    info.width,
                    info.height,
                    info.pitch,
                    info.pointer,
                    info.virtual_height,
                    info.size
                );
                if !uncached {
                    crate::warn!("[GPU] VRAM in cached RAM region (<0x38000000)!");
                }
                fb_info = Some(info);
                break;
            } else {
                crate::debug!("[GPU] Mailbox OK but parse failed for {}x{}", w, h);
            }
        } else {
            crate::debug!("[GPU] Mailbox call failed for {}x{}", w, h);
        }
    }

    let info = match fb_info {
        Some(i) => i,
        None => {
            crate::error!(
                "[GPU] FATAL: FrameBuffer allocation failed for all resolutions. Halting."
            );
            loop {
                unsafe {
                    core::arch::asm!("wfe");
                }
            }
        }
    };
    crate::println!("{:.<50} [OK]", "1. Graphics System (FrameBuffer)");
    // 起動時スプラッシュ画面の初期化と表示 (黒画面クリアのみ先行)
    unsafe {
        let pitch = if info.pitch == 0 {
            info.width * 4
        } else {
            info.pitch
        };
        let screen = Screen::new(info.pointer, info.width, info.height, pitch);
        CURRENT_SCREEN = Some(screen);
        kernel::draw::SPLASH_ACTIVE = true;
        if let Some(ref screen) = CURRENT_SCREEN {
            screen.clear(kernel::draw::Color(0xFF000000));
        }
    }

    // 3. 例外ベクタテーブルを VBAR_EL1 に登録
    let vector_addr = unsafe { &exception_vector_table as *const u8 as usize };
    unsafe {
        core::arch::asm!("msr vbar_el1, {}", in(reg) vector_addr);
    }
    crate::info!(
        "[SYS] Exception Vector Table registered at 0x{:016X}",
        vector_addr
    );

    // 4. MMU恒等マップ（16KBページ＆L1/L2キャッシュ）を有効化
    kernel::mmu::init();

    // VideoCore IV V3D 初期化
    if let Err(e) = crate::kernel::v3d::init() {
        crate::warn!("[V3D] V3D Init Error: {}", e);
    }

    // 5. カーネルヒープアロケータの初期化
    let heap_start = unsafe { &__cpu_stacks_end as *const u8 as usize };
    // 大きさは `allocator::KERNEL_HEAP_SIZE` が唯一の定義。
    // `fs/mod.rs` がヒープ直後から RAMDisk を取るので、
    // ここで別の値を書くと領域が重なる。
    let heap_size = kernel::allocator::KERNEL_HEAP_SIZE;
    kernel::allocator::init(heap_start, heap_size);
    crate::info!(
        "[MEM] Kernel Heap Allocator initialized. (Heap start: 0x{:016X}, Heap size: 512 MB)",
        heap_start
    );
    crate::println!("{:.<50} [OK]", "2. Memory System (MMU & Heap)");
    // ヒープアロケータが有効になったのでロゴを描画
    unsafe {
        kernel::draw::draw_splash_logo();
    }

    // 起動時セルフテスト群は `selftest` feature（CI/開発ビルドのみ）で有効化する。
    // 通常起動（make run）ではこのブロックごとコンパイルされないため、起動が速くなり、
    // かつテストコード側の不具合（かつての decompress_brotli スタックオーバーフローや、
    // JS 集計ずれ→`tests_failed`→`wfe` 無限ループ等）が本番起動を巻き込むことを防ぐ。
    // 回帰検出は CI（`--features selftest` + `test_browser.sh`）で従来通り行う。
    #[cfg(feature = "selftest")]
    {
    // 各自己テストをサイレントモードで実行
    let mut tests_failed = false;
    kernel::uart::set_silent(true);

    let mut js_ok = false;
    let mut bigint_ok = false;
    let mut aura_ok = false;
    let mut css_ok = false;
    let mut layout_ok = false;
    let mut ime_ok = false;
    let mut cloud_ok = false;
    let mut h264_ok = false;
    let mut h264_golden_ok = false;
    let mut reclock_ok = false;
    let mut fs_ok = false;
    let mut usbsched_ok = false;

    // 【安全性・重要、2026-07-23】この起動時診断行はここに置かれた `decompress_brotli`
    // 呼び出し自体（入力値を`[3]`/`[6]`いずれに変えても）が、この起動シーケンス最早期・
    // 低ヒープフラグメント状態で毎回QEMU起動を完全にハングさせることを実証したため、
    // 呼び出しごと削除した（`woff2_brotli_ok`はどのテストのpass/fail判定にも使われて
    // いない純粋な診断ログ専用の値であり、削除しても機能上の後退は無い）。
    // `decompress_brotli`のアロケータ状態依存のハングは既知の未解決リスクであり、
    // 根本原因が特定されるまでこの関数を起動パスの早期段階で無条件に呼び出しては
    // ならない。詳細は spec/walkthrough.md 参照。

    // 【2026-07-24 発見・追加】各カテゴリの合否は`pass == total`の一言判定のみで、
    // 個別テストの`JS_SELFTEST FAIL: ...`行が一件も出ないまま（＝全ケースが
    // 実際にはPASSしているにも関わらず）カテゴリ丸ごとFAIL表示になる「集計ずれ」
    // （`total`側の手計算の合計式が実際のケース数とズレる等）が起きても、
    // どこが食い違っているのか一切わからなかった。成功時は従来どおり静かなまま、
    // 失敗時のみ`pass`/`total`の実数値を出力し、個別FAIL行が無いのに合計だけ
    // 合わない「集計ずれ」なのか、実際に個別テストが落ちているのかを区別できる
    // ようにする。

    // JS
    let (pass, total) = os_lib::js::selftest();
    if pass == total {
        js_ok = true;
    } else {
        tests_failed = true;
        crate::println!("[SELFTEST] JS: {}/{} passed", pass, total);
    }

    // BigInt
    let (pass, total) = os_lib::js::bigint::selftest();
    if pass == total {
        bigint_ok = true;
    } else {
        tests_failed = true;
        crate::println!("[SELFTEST] BigInt: {}/{} passed", pass, total);
    }

    // Aura
    let (pass, total) = os_lib::aura::selftest();
    if pass == total {
        aura_ok = true;
    } else {
        tests_failed = true;
        crate::println!("[SELFTEST] Aura: {}/{} passed", pass, total);
    }

    // CSS
    let (pass, total) = os_lib::css::selftest();
    if pass == total {
        css_ok = true;
    } else {
        tests_failed = true;
        crate::println!("[SELFTEST] CSS: {}/{} passed", pass, total);
    }

    // Layout
    let (pass, total) = os_lib::layout::selftest();
    if pass == total {
        layout_ok = true;
    } else {
        tests_failed = true;
        crate::println!("[SELFTEST] Layout: {}/{} passed", pass, total);
    }

    // IME
    let (pass, total) = kernel::ime::selftest();
    if pass == total {
        ime_ok = true;
    } else {
        tests_failed = true;
        crate::println!("[SELFTEST] IME: {}/{} passed", pass, total);
    }

    // Cloud
    let (pass, total) = os_lib::cloud::selftest();
    if pass == total {
        cloud_ok = true;
    } else {
        tests_failed = true;
        crate::println!("[SELFTEST] Cloud: {}/{} passed", pass, total);
    }

    // H264
    let (pass, total) = os_lib::h264::selftest();
    if pass == total {
        h264_ok = true;
    } else {
        tests_failed = true;
        crate::println!("[SELFTEST] H264: {}/{} passed", pass, total);
    }

    // H264 Golden
    if os_lib::h264_decode::golden_test() {
        h264_golden_ok = true;
    } else {
        tests_failed = true;
        crate::println!("[SELFTEST] H264 Golden: failed");
    }

    // Reclock
    if kernel::reclock::selftest() {
        reclock_ok = true;
    } else {
        tests_failed = true;
        crate::println!("[SELFTEST] Reclock: failed");
    }

    // FS
    let (pass, total) = kernel::fs::selftest();
    if pass == total {
        fs_ok = true;
    } else {
        tests_failed = true;
        crate::println!("[SELFTEST] FS: {}/{} passed", pass, total);
    }

    // USB Sched
    let (pass, total) = kernel::usb::frame_sched::selftest();
    if pass == total {
        usbsched_ok = true;
    } else {
        tests_failed = true;
        crate::println!("[SELFTEST] USB Sched: {}/{} passed", pass, total);
    }

    kernel::uart::set_silent(false);

    let js_str = if js_ok {
        "JS_SELFTEST: PASS"
    } else {
        "JS_SELFTEST: FAIL"
    };
    let bigint_str = if bigint_ok {
        "BIGINT_SELFTEST: PASS"
    } else {
        "BIGINT_SELFTEST: FAIL"
    };
    let aura_str = if aura_ok {
        "AURA_SELFTEST: PASS"
    } else {
        "AURA_SELFTEST: FAIL"
    };
    let css_str = if css_ok {
        "CSS_SELFTEST: PASS"
    } else {
        "CSS_SELFTEST: FAIL"
    };
    let layout_str = if layout_ok {
        "LAYOUT_SELFTEST: PASS"
    } else {
        "LAYOUT_SELFTEST: FAIL"
    };
    let ime_str = if ime_ok {
        "IME_SELFTEST: PASS"
    } else {
        "IME_SELFTEST: FAIL"
    };
    let cloud_str = if cloud_ok {
        "CLOUD_SELFTEST: PASS"
    } else {
        "CLOUD_SELFTEST: FAIL"
    };
    let h264_str = if h264_ok {
        "H264_SELFTEST: PASS"
    } else {
        "H264_SELFTEST: FAIL"
    };
    let h264_golden_str = if h264_golden_ok {
        "H264_GOLDEN: PASS"
    } else {
        "H264_GOLDEN: FAIL"
    };
    let reclock_str = if reclock_ok {
        "RECLOCK_SELFTEST: PASS"
    } else {
        "RECLOCK_SELFTEST: FAIL"
    };
    let fs_str = if fs_ok {
        "FS_SELFTEST: PASS"
    } else {
        "FS_SELFTEST: FAIL"
    };
    let usbsched_str = if usbsched_ok {
        "USBSCHED_SELFTEST: PASS"
    } else {
        "USBSCHED_SELFTEST: FAIL"
    };

    if !tests_failed {
        // expectが順次アサーションできるようにPASSマーカーを1行に埋め込む
        crate::println!(
            "3. Core Software Self-Tests ({}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}) [OK]",
            js_str,
            bigint_str,
            aura_str,
            css_str,
            layout_str,
            ime_str,
            cloud_str,
            h264_str,
            h264_golden_str,
            reclock_str,
            fs_str,
            usbsched_str
        );
    } else {
        crate::println!(
            "3. Core Software Self-Tests ({}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}) [FAIL]",
            js_str,
            bigint_str,
            aura_str,
            css_str,
            layout_str,
            ime_str,
            cloud_str,
            h264_str,
            h264_golden_str,
            reclock_str,
            fs_str,
            usbsched_str
        );
        loop {
            unsafe {
                core::arch::asm!("wfe");
            }
        }
    }
    } // end #[cfg(feature = "selftest")] 起動時セルフテスト群

    // 起動時セルフテスト群はスタック使用量が最も深くなりやすい経路（かつて
    // `decompress_brotli`のスタック配列がここで64KBコアスタックを溢れさせ、
    // 無音のままブート全体をフリーズさせていた）だったため、直後に番兵を
    // 確認する。`selftest` feature が無効なビルドでも呼ぶことで、将来他の
    // 経路がスタックを溢れさせた場合の検知にも流用できる。
    unsafe {
        if !check_stack_canary() {
            report_stack_canary_violation("selftest block (main.rs)");
        }
    }

    // 6. 独自ファイルシステム SylFS のマウント
    // マウントは失敗しても起動を続けるが、**[OK] と表示してはいけない**
    // （フォーマットできていないのに正常起動に見えると、以後の「保存できない」
    //  という症状の原因がここだと誰も気づけない）。
    match kernel::fs::mount() {
        Ok(()) => crate::println!("{:.<50} [OK]", "4. File System (SylFS)"),
        Err(e) => {
            crate::error!("[FS] Mount completed with errors: {}", e);
            crate::println!("{:.<50} [NG] {}", "4. File System (SylFS)", e);
        }
    }

    // 6.5 Phase 3 ネットワークコア初期化（現時点ではソフト実装）
    kernel::net::init();

    // 7. スクリーンオブジェクトの作成
    let pitch = if info.pitch == 0 {
        info.width * 4
    } else {
        info.pitch
    };
    let screen = Screen::new(info.pointer, info.width, info.height, pitch);
    // ダブルバッファ（2 ページ = virtual_height 2*H）が実際に確保できたかを Screen に伝える。
    // enable_vsync() がこれを見て、確保できた時だけページフリップを有効化する
    // （未確保のまま flip すると page1 がフレームバッファ外を指し横線ノイズになる）。
    screen.set_fb_geometry(info.virtual_height, info.size);
    unsafe {
        CURRENT_SCREEN = Some(screen);
    }
    kernel::audio::Audio::init();
    crate::info!("[GPU] Screen initialization completed!");
    crate::println!("{:.<50} [OK]", "5. Audio Systems");

    // 8. プロセススケジューラの初期化
    kernel::scheduler::init();

    // デモプロセスの起動 (ここをチャットUI of プロセスに差し替える)
    kernel::scheduler::spawn_on_core(
        gui_shell_process,
        kernel::scheduler::Priority::High,
        "gui_shell",
        0,
    );

    // EL0テストプロセスは確認済みのためコメントアウト
    // kernel::scheduler::spawn_user_on_core(
    //     user_test_normal,
    //     kernel::scheduler::Priority::Normal,
    //     "user_test_normal",
    //     0,
    // );
    // kernel::scheduler::spawn_user_on_core(
    //     user_test_abort,
    //     kernel::scheduler::Priority::Normal,
    //     "user_test_abort",
    //     0,
    // );

    // 9. 割り込みコントローラと全体の割り込みを有効化
    crate::info!("[SYS] Initializing Interrupt Controller...");
    kernel::interrupt::init();

    // 10. タイマー割り込み（10ms）の有効化
    kernel::timer::init();

    // 10.5. USB ホストコントローラの初期化と列挙を「割り込み有効化の前」に実行する。

    kernel::usb::init();

    kernel::interrupt::enable_interrupts();
    crate::println!("{:.<50} [OK]", "6. USB Host Controller & HID Stack");

    crate::println!("{:.<50} [OK]", "7. System Scheduler & Interrupts");
    crate::println!("--------------------------------------------------");
    crate::println!("   AtmOS OS Base Phase 3 (merged) running!");
    crate::println!("   Author: SUGIMURA Hiroshi (Sugimura Laboratoly)");
    crate::println!("--------------------------------------------------");
    unsafe {
        kernel::draw::SPLASH_ACTIVE = false;
    }

    crate::info!("[SYS] Waking up secondary cores...");
    unsafe {
        // 1. Write startup address (jump to secondary_entry trampoline).
        // For physical hardware (spinning on spin_cpu variables)
        core::ptr::write_volatile(
            &mut spin_cpu1 as *mut u64,
            secondary_entry as *const () as u64,
        );
        core::ptr::write_volatile(
            &mut spin_cpu2 as *mut u64,
            secondary_entry as *const () as u64,
        );
        core::ptr::write_volatile(
            &mut spin_cpu3 as *mut u64,
            secondary_entry as *const () as u64,
        );

        // For QEMU (spinning on mailboxes 0xe0, 0xe8, 0xf0)
        core::ptr::write_volatile(0xe0 as *mut u64, secondary_entry as *const () as u64);
        core::ptr::write_volatile(0xe8 as *mut u64, secondary_entry as *const () as u64);
        core::ptr::write_volatile(0xf0 as *mut u64, secondary_entry as *const () as u64);

        // 2. Force compiler to issue writes before inline assembly
        core::sync::atomic::compiler_fence(core::sync::atomic::Ordering::SeqCst);

        // 3. Clean cache to Point of Coherency (DDR)
        core::arch::asm!(
            "dc cvac, {}",
            "dc cvac, {}",
            "dc cvac, {}",
            "dsb sy",
            in(reg) &spin_cpu1 as *const u64,
            in(reg) &spin_cpu2 as *const u64,
            in(reg) &spin_cpu3 as *const u64,
        );

        // Clean cache for QEMU mailboxes
        core::arch::asm!(
            "dc cvac, {0}",
            "dc cvac, {1}",
            "dc cvac, {2}",
            "dsb sy",
            in(reg) 0xe0usize,
            in(reg) 0xe8usize,
            in(reg) 0xf0usize,
        );

        // 4. Wake up cores
        core::arch::asm!("sev");
    }

    // カーネルのメインコンテキストはダミープロセス0として他のスレッドへ制御を譲り続けます
    loop {
        kernel::scheduler::yield_now();
    }
}

#[no_mangle]
pub extern "C" fn secondary_startup() -> ! {
    let core_id: usize;
    unsafe {
        let mpidr: u64;
        core::arch::asm!("mrs {}, mpidr_el1", out(reg) mpidr);
        core_id = (mpidr & 0xFF) as usize;
    }
    crate::debug!("[SMP] Core {}: secondary_startup entry", core_id);

    // VBARの設定
    let vector_addr = unsafe { &exception_vector_table as *const u8 as usize };
    unsafe {
        core::arch::asm!("msr vbar_el1, {}", in(reg) vector_addr);
    }
    crate::debug!("[SMP] Core {}: VBAR set", core_id);

    // MMUとキャッシュを有効化（secondary では一度だけ実行）
    kernel::mmu::init_secondary();
    crate::debug!("[SMP] Core {}: MMU ready", core_id);

    // 割り込みコントローラ設定 -> タイマー有効化 の順で初期化
    kernel::interrupt::init_secondary();
    crate::debug!("[SMP] Core {}: IRQ controller ready", core_id);
    kernel::timer::init_secondary();
    crate::debug!("[SMP] Core {}: timer ready", core_id);

    // コア起動完了は 1 行サマリのみ常時表示
    println!("[SMP] Core {} started!", core_id);

    // スケジューラに idle プロセスを登録
    kernel::scheduler::register_idle_process(core_id);

    // 割り込みを許可してスケジューラの稼働を待つ
    kernel::interrupt::enable_interrupts();

    // スケジューラのループに入るか待機
    loop {
        kernel::scheduler::yield_now();
    }
}

/// GUIシェルプロセス（チャットUI）
static mut TABLET_MAX_X: u32 = 32768;
static mut TABLET_MAX_Y: u32 = 32768;

fn usb_poll_thread() {
    crate::warn!(
        "USB Poll Thread started on Core {}",
        crate::kernel::scheduler::core_id()
    );
    unsafe {
        crate::kernel::usb::POLL_THREAD_ACTIVE = true;
    }
    let mut divider: u32 = 0;
    loop {
        crate::kernel::usb::poll();
        divider = divider.wrapping_add(1);
        if divider.is_multiple_of(32) {
            crate::kernel::net::dhcp_tick();
        }
        // NTP 同期はこのスレッドからは行わない。ntp_sync() は最大数十秒ブロックし得るため、
        // ここで呼ぶと HID(キーボード/タブレット) ポーリングが停止し入力フリーズの原因になる。
        // 同期処理は net_service_thread に分離した。
        // ヒープ canary の定期診断: バッファオーバーフローの発生源を最初の破損時点で捕捉する。
        // 一度検出したら以後は走査しない（最初の証拠を上書きしない・コストをかけない）。
        static mut HEAP_CORRUPTION_FOUND: bool = false;
        if divider.is_multiple_of(4096)
            && unsafe { !HEAP_CORRUPTION_FOUND }
            && crate::kernel::allocator::check_heap_integrity()
        {
            unsafe {
                HEAP_CORRUPTION_FOUND = true;
            }
        }
        let start = crate::kernel::timer::get_system_time_ms();
        while crate::kernel::timer::get_system_time_ms().wrapping_sub(start) < 8 {
            unsafe { core::arch::asm!("nop") };
        }
        crate::kernel::scheduler::yield_now(); // 10msウェイトから即時譲渡へ変更してレイテンシを極小化
    }
}

/// ネットワークサービススレッド（NTP 同期などのブロッキング処理を担当）。
/// HID ポーリング(usb_poll_thread)から分離することで、NTP の長時間ブロックが
/// キーボード/タブレット入力を固める「起動直後フリーズ」を解消する。
fn net_service_thread() {
    crate::info!(
        "Net Service Thread started on Core {}",
        crate::kernel::scheduler::core_id()
    );
    let mut ntp_last_attempt_ms: u64 = 0;
    loop {
        // 【2026-07-24発見・修正】`poll_ethernet_data_plane_only()`はマルチコア
        // でのUSBレジスタ/DMA_BUF競合を避けるためCore 2からの呼び出しのみ実際に
        // 動作する設計だが、このスレッド自身の処理はNTP同期（起動直後・壁時計が
        // 未設定の間だけ）に限られており、NTP同期完了後は一切ポーリングされて
        // いなかった。このため「他コア（GUIレンダリングスレッド等）から開始した
        // TCP/TLS接続は、たまたまこのスレッドがNTP同期でポーリング中でなければ
        // 誰にもパケットを処理してもらえずタイムアウトする」という重大なバグの
        // 原因となっていた（実サイトのメインHTML取得は成功するのに、直後の外部
        // CSS取得が毎回TLSハンドシェイクに失敗する現象として顕在化）。
        // Core 2は本来この用途の専用スレッドなので、NTP同期の有無に関わらず
        // 毎ループ確実にポーリングするよう変更する。
        crate::kernel::usb::poll_ethernet_data_plane_only();

        // リンクアップ後、壁時計が未同期なら NTP(NICT) で同期を試みる（30秒間隔）。
        // ntp_sync() は内部で poll_ethernet_data_plane_only() を回しつつ最大数十秒ブロックし得るが、
        // ここは専用スレッドなので HID ポーリングを妨げない。
        let net_st = crate::kernel::net::status();
        if !crate::kernel::timer::is_wall_clock_set() && net_st.link_up && net_st.ip != [0; 4] {
            let now = crate::kernel::timer::get_system_time_ms();
            if ntp_last_attempt_ms == 0 || now.wrapping_sub(ntp_last_attempt_ms) > 30_000 {
                ntp_last_attempt_ms = now;
                if let Err(e) = crate::kernel::net::ntp_sync() {
                    crate::warn!("[SYS] NTP sync failed: {}", e);
                }
            }
        } else if net_st.ip == [0; 4] {
            // IP未設定の間は試行タイマーをリセットし続けることで、IP取得直後に即同期できるようにする
            ntp_last_attempt_ms = 0;
        }
        // ポーリング自体は毎ループ行うが、CPUを独占しないよう短く譲る。
        // 【2026-07-30 検証したが戻した】ポーリング間隔を 100ms→20ms、
        // 1 回の回収上限を 8→64 に増やしたところ、実機で **8/8 全滅**した
        // （それまでは 1〜3 回成功していた）。ポーリングを詰めると
        // USB レジスタへのアクセスが増え、かえって転送を阻害するとみられる。
        // 「速くすれば改善する」という思い込みを実測が否定した。
        // 再挑戦するなら間隔と回収数を**片方ずつ**変えて測ること。
        //
        // 【2026-08-05】この間隔が画像取得の律速そのものだと実測で確定した。
        // 100ms × 1 回 8 フレーム × 1500 バイト = 120KB/s で、
        // 実効 100KB/s とほぼ一致する。
        //
        // 2026-07-30 は間隔と回収数を**同時に**変えて全滅したが、
        // 今回**回収数だけ** 8→32 にしたところ 13/13 成功のまま
        // 2.3 倍遅くなった（fetch 3685→8329 tick）。
        // つまり全滅の原因は回収数ではない。残るのは間隔の方。
        //
        // 【2026-08-05】眠らずに譲るだけにした。
        //
        // ## 経緯
        //
        // 間隔を 100ms→50ms にしても取得は速くならなかった
        // （fetch 3685→3907tick）。当時は「間隔は律速ではない」と結論したが、
        // **理由は Core 1 の `poll()` が受信の 87% を担っていたから**で、
        // このスレッドの間隔を変えても全体はほとんど動かなかっただけだった。
        //
        // Ethernet 収穫を Core 1 から外して当スレッドへ一本化したので、
        // 今度はこの間隔が受信頻度そのものになる。
        // 1 回の収穫は実測 8ms（`hid_eth_us`/`hid_calls` より）なので、
        // 10ms 眠ると半分以上を寝て過ごすことになる。
        // 専用スレッドなので `yield_now` で詰めてみたが、
        // **3.7MB の画像が 200 秒で完了しなくなり明確に悪化した**ため戻した。
        // Core 2 には画像取得ワーカーも載るので、譲ると番が回ってこない。
        // 受信を実際に駆動しているのは Core 1 の `poll()` の方だった。
        crate::kernel::scheduler::sleep(10);
    }
}

fn gui_shell_process() {
    crate::info!(
        "GUI Shell process has started on Core {}",
        crate::kernel::scheduler::core_id()
    );
    crate::os_lib::svg::init_cache();

    let Some(screen) = (unsafe { CURRENT_SCREEN.as_mut() }) else {
        crate::println!("GUI Shell: CURRENT_SCREEN is not initialized. Aborting GUI shell.");
        return;
    };

    // USB ホストコントローラの初期化と列挙は、プリエンプション無効の単一スレッド区間で
    // 走らせるため main()（enable_interrupts の直前）へ移動済み。ここでは何もしない。

    // WiFi (CYW43455 SDIO) の初期化
    crate::info!("[NET] Initializing WiFi SDIO controller...");
    if kernel::sdio::init() {
        crate::info!("[NET] SDIO initialized. Starting WiFi driver...");
        if kernel::wifi::init() {
            crate::info!("[NET] WiFi ready.");
        } else {
            crate::info!("[NET] WiFi init failed (firmware may be missing from /boot/).");
        }
    } else {
        crate::info!("[NET] SDIO init failed (no WiFi chip detected).");
    }

    // USB初期化完了後にポーリングスレッドをCore 1に割り当てる
    kernel::scheduler::spawn_on_core(
        usb_poll_thread,
        kernel::scheduler::Priority::High,
        "usb_poll",
        1,
    );

    // NTP 等のブロッキングなネットワーク処理を担当する専用スレッド。
    // HID ポーリング(usb_poll)と分離することで、NTP の長時間ブロックが
    // 入力フリーズを引き起こさないようにする。Core 2 に割り当てる。
    kernel::scheduler::spawn_on_core(
        net_service_thread,
        kernel::scheduler::Priority::Normal,
        "net_service",
        2,
    );

    // ベクトルフォントのロードと初期化 (include_bytes! によりカーネルに直結してメモリ展開)
    // フォールバックチェーン: config の font_names 順でグリフを補う。
    let conf = kernel::config::get_config();
    crate::info!("[GPU] Initializing Vector Font Engine: {:?}...", conf.font_names);
    let chain: alloc::vec::Vec<&str> = conf.font_names.iter().map(|s| s.as_str()).collect();
    kernel::vector_font::init_global_font_chain(&chain);
    kernel::vector_font::init_terminal_font();
    crate::info!("[GPU] Vector Font initialized successfully!");

    // Webブラウザの初期化
    crate::info!("[SYS] Initializing Web Browser...");
    apps::browser::init();
    crate::info!("[SYS] Web Browser initialized successfully!");

    crate::info!("[SYS] Initializing Window Manager...");
    kernel::window_mgr::init();
    crate::info!("[SYS] Window Manager initialized successfully!");

    crate::info!("[SYS] Initializing Terminal...");

    // 設定の読み込みは失敗しても起動は続けるが、**握り潰さずに必ず報告する**
    // （「設定したのに効かない」の原因がログに残らないのを防ぐ）。
    let loaded_config = crate::kernel::config::init_or_load();
    if let Err(e) = loaded_config.status {
        crate::error!(
            "[SYS] Configuration loaded with errors (defaults were used): {}",
            e
        );
    }
    let os_config = loaded_config.config;
    crate::kernel::net::set_dhcp_auto_pending(os_config.auto_dhcp);

    let mut terminal = crate::apps::terminal::Terminal::new();

    let mut mouse_tracker = crate::kernel::mouse_tracker::MouseTracker::new(
        (screen.width - 16) / 2,
        (screen.height - 28 - 16) / 2,
        screen.width,
        screen.height,
    );
    let mut mx = mouse_tracker.x;
    let mut my = mouse_tracker.y;
    let mut mouse_obj = kernel::draw::Mouse::new(mx, my);

    let mut shortcut_mgr = crate::kernel::shortcut_manager::ShortcutManager::new();
    use crate::kernel::shortcut_manager::{InputAction, Modifiers, Shortcut, ShortcutLayer};
    // OS Shortcuts
    shortcut_mgr.register(Shortcut::new(
        0x48,
        Modifiers::new(false, true, false),
        ShortcutLayer::OS,
        InputAction::SwitchTabRelative(-1),
    )); // Alt+Up
    shortcut_mgr.register(Shortcut::new(
        0x50,
        Modifiers::new(false, true, false),
        ShortcutLayer::OS,
        InputAction::SwitchTabRelative(1),
    )); // Alt+Down
    shortcut_mgr.register(Shortcut::new(
        0x14,
        Modifiers::new(false, true, false),
        ShortcutLayer::OS,
        InputAction::NewTab,
    )); // Alt+T
    shortcut_mgr.register(Shortcut::new(
        0x11,
        Modifiers::new(false, true, false),
        ShortcutLayer::OS,
        InputAction::CloseTab,
    )); // Alt+W
    shortcut_mgr.register(Shortcut::new(
        0x18,
        Modifiers::new(false, true, false),
        ShortcutLayer::OS,
        InputAction::OpenFileDialog,
    )); // Alt+O
    shortcut_mgr.register(Shortcut::new(
        0x1F,
        Modifiers::new(false, true, false),
        ShortcutLayer::OS,
        InputAction::SaveFile,
    )); // Alt+S
    shortcut_mgr.register(Shortcut::new(
        0x01,
        Modifiers::new(false, false, false),
        ShortcutLayer::OS,
        InputAction::ToggleFocusSysmonTerminal,
    )); // Esc

    let mut kbd = crate::kernel::keyboard::Keyboard::new();
    kbd.set_layout(os_config.keyboard_layout);
    let mut mouse_dec = crate::kernel::mouse::MouseDecoder::new();
    let mut input_state = 0;
    let mut ime_state = crate::kernel::ime::ImeState::new();
    // Mozc 辞書(7.8万語)は重い。初回 IME 切替時にメインスレッドで読むと使用中にフリーズするため、
    // 起動初期化フェーズ（ここ）で先に読み込んでおく。
    ime_state.load_dict();

    // タブレット用の一時変数
    let mut tablet_btn = 0u32;
    let mut tablet_abs_x = 0u32;
    let mut tablet_abs_y = 0u32;

    let mut login_mgr = crate::apps::login::LoginManager::new();
    let _first_unlock = true;

    // 動的レイアウトの計算
    let tab_w = 100;
    let sysmon_w = if screen.width >= 1920 { 518 } else { 300 };
    let sysmon_x = screen.width - sysmon_w;
    let center_w = sysmon_x - tab_w - 2;
    // 画面最下部のファンクションキー・ガイドバー分を除いた表示高さ
    let content_h = screen.height.saturating_sub(kernel::fn_bar::BAR_HEIGHT);

    // 固定システムモニターペインの初期化（バーと重ならないよう高さを制限）
    let mut sysmon_pane =
        kernel::window::SystemMonitorPane::new(sysmon_x as i32 + 2, 0, sysmon_w - 2, content_h);

    // 実機デバッグ: フレームバッファの実ジオメトリを出力（SMP 起床後の静かな区間なので化けない）。
    screen.debug_geometry();
    screen.enable_double_buffering();
    // VSync ページフリップは 2 ページが確保できた場合のみ有効化する。
    let vsync_on = screen.enable_vsync();
    if vsync_on {
        println!("[FB] VSync page-flip ENABLED (double buffer / 2 pages confirmed)");
    } else {
        println!("[FB] VSync page-flip DISABLED (single buffer; 2 pages not allocated)");
    }
    let mut last_render_time = crate::kernel::timer::get_system_time_ms();
    let mut last_sysmon_ticks = 0;

    let mut power_modal_visible = false;
    let mut pwr_last_mouse_btn = false;
    let mut first_render = true;
    let mut was_unlocked = login_mgr.is_unlocked();

    // マイルストーン（CI が expect で待つ）: 閾値に関わらず常に出す → warn!
    crate::warn!("[SYS] === GUI Shell: All initialization complete. Entering main loop ===");
    unsafe {
        crate::kernel::dialog::GLOBAL_FILE_DIALOG = Some(crate::kernel::dialog::FileDialog::new());
    }

    loop {
        // kernel::usb::poll() は usb_poll_thread (Core 1) にオフロードされました

        let mut processed_any = false;

        loop {
            let (kbd_data, mouse_data, uart_data) = {
                crate::kernel::interrupt::disable_interrupts();
                let kd = crate::kernel::interrupt::KBD_FIFO.lock().pop();
                let md = crate::kernel::interrupt::MOUSE_FIFO.lock().pop();
                let ud = crate::kernel::interrupt::UART_FIFO.lock().pop();
                crate::kernel::interrupt::enable_interrupts();
                (kd, md, ud)
            };

            if kbd_data.is_none() && mouse_data.is_none() && uart_data.is_none() {
                break;
            }
            processed_any = true;

            // --- シリアルコンソール入力 ---
            // UART で届いた ASCII バイトを合成スキャンコードへ展開し、物理キーボードと
            // 全く同じ decode() → process_key_event パイプラインに流す。
            // これによりログイン・ターミナル・IME 等が一切区別なく動作し、
            // QEMU の expect スクリプト等によるシリアル自動操作 (回帰テスト) が可能になる。
            if let Some(byte) = uart_data {
                let b = byte as u8;
                if b < 0x80 {
                    let layout = crate::kernel::config::get_config().keyboard_layout;
                    if let Some((kc, shift)) =
                        crate::kernel::keyboard::ascii_to_scancode(b as char, layout)
                    {
                        // make/break を最大4つ (Shift make, key make, key break, Shift break)
                        let mut seq = [0u8; 4];
                        let mut n = 0;
                        if shift {
                            seq[n] = 0x2A;
                            n += 1;
                        } // LShift make
                        seq[n] = kc;
                        n += 1; // key make
                        seq[n] = kc | 0x80;
                        n += 1; // key break
                        if shift {
                            seq[n] = 0xAA;
                            n += 1;
                        } // LShift break
                        for &sc in &seq[..n] {
                            if let Some(ev) = kbd.decode(sc) {
                                process_key_event(
                                    ev,
                                    1,
                                    &mut terminal,
                                    &mut kbd,
                                    &mut ime_state,
                                    &mut login_mgr,
                                    &mut sysmon_pane,
                                    &mut power_modal_visible,
                                    screen,
                                    &shortcut_mgr,
                                );
                            }
                        }
                    }
                }
            }

            if let Some(data_u32) = mouse_data {
                let val = data_u32 as u8;
                match input_state {
                    0 => {
                        if val == 0xFE {
                            input_state = 2;
                        } else if val == 0xFC {
                            input_state = 5;
                        }
                    }

                    2 => {
                        let _ = mouse_dec.decode(val);
                        input_state = 3;
                    }
                    3 => {
                        let _ = mouse_dec.decode(val);
                        input_state = 4;
                    }
                    4 => {
                        if let Some(mev) = mouse_dec.decode(val) {
                            mouse_tracker.move_relative(mev.dx, mev.dy);
                            mx = mouse_tracker.x;
                            my = mouse_tracker.y;

                            let left_click = mev.left_btn;
                            let just_pressed = left_click && !pwr_last_mouse_btn;
                            pwr_last_mouse_btn = left_click;

                            if power_modal_visible {
                                if just_pressed {
                                    let cx = screen.width / 2;
                                    let cy = screen.height / 2;
                                    if mx >= cx - 150 && mx <= cx + 150 {
                                        if my >= cy - 60 && my <= cy - 20 {
                                            // Shutdown
                                            unsafe {
                                                screen.clear(kernel::draw::Color::BLACK);
                                                screen.draw_string_vector(cx.saturating_sub(250), cy - 10, "System Halted. You can safely turn off your machine.", kernel::draw::Color::WHITE, 24);
                                                screen.flush();
                                                loop {
                                                    core::arch::asm!("wfe");
                                                }
                                            }
                                        } else if my >= cy && my <= cy + 40 {
                                            // Reboot using Watchdog
                                            unsafe {
                                                let rstc = 0x3F10_001C as *mut u32;
                                                let wdog = 0x3F10_0024 as *mut u32;
                                                core::ptr::write_volatile(wdog, 0x5A00_0000 | 10);
                                                let mut rstc_val = core::ptr::read_volatile(rstc);
                                                rstc_val = (rstc_val & 0xFFFF_FFCF) | 0x5A00_0020;
                                                core::ptr::write_volatile(rstc, rstc_val);
                                                loop {
                                                    core::arch::asm!("wfe");
                                                }
                                            }
                                        } else if my >= cy + 60 && my <= cy + 100 {
                                            // Cancel
                                            power_modal_visible = false;
                                            let mut wm = kernel::window_mgr::get_instance();
                                            wm.dirty = true;
                                        }
                                    }
                                }
                            } else {
                                let mut wm_handled = false;
                                if login_mgr.is_unlocked() {
                                    let mut wm = kernel::window_mgr::get_instance();
                                    wm_handled = wm.handle_mouse(
                                        mx as i32,
                                        my as i32,
                                        left_click,
                                        mev.right_btn,
                                        0,
                                        screen,
                                    );
                                    // ターミナルランチャー: クリックでアプリ起動
                                    if wm.terminal_focused && just_pressed {
                                        if let Some(app_name) = terminal.handle_click(mx as i32, my as i32) {
                                            let cmd = alloc::format!("os.run(\"{}\")", app_name);
                                            if let Some(ctx) = &terminal.context {
                                                ctx.cmd_queue.push(cmd);
                                            }
                                            terminal.print_line(alloc::format!("> run {}", app_name));
                                            terminal.dirty = true;
                                            wm.dirty = true;
                                        }
                                    }
                                }

                                if wm_handled {
                                    sysmon_pane.handle_mouse(-1, -1, left_click);
                                } else {
                                    let sysmon_handled =
                                        sysmon_pane.handle_mouse(mx as i32, my as i32, left_click);
                                    if sysmon_pane.wants_power_menu {
                                        power_modal_visible = true;
                                        sysmon_pane.wants_power_menu = false;
                                        let mut wm = kernel::window_mgr::get_instance();
                                        wm.dirty = true;
                                    }
                                    if !sysmon_handled && !login_mgr.is_unlocked() {
                                        login_mgr.handle_mouse_input(mx, my, left_click, 0);
                                    }
                                }
                            }
                        }
                        input_state = 0;
                    }
                    5 => {
                        tablet_btn = data_u32;
                        input_state = 6;
                    }
                    6 => {
                        tablet_abs_x = data_u32;
                        input_state = 7;
                    }
                    7 => {
                        tablet_abs_y = data_u32;
                        input_state = 8;
                    }
                    8 => {
                        let tablet_wheel = data_u32 as i8 as i32;
                        mouse_tracker.move_absolute_tablet(
                            tablet_abs_x,
                            tablet_abs_y,
                            unsafe { TABLET_MAX_X },
                            unsafe { TABLET_MAX_Y },
                        );
                        mx = mouse_tracker.x;
                        my = mouse_tracker.y;

                        let left_click = (tablet_btn & 0x01) != 0;
                        let right_click = (tablet_btn & 0x02) != 0;
                        let just_pressed = left_click && !pwr_last_mouse_btn;
                        pwr_last_mouse_btn = left_click;

                        let mut dialog_handled = false;
                        unsafe {
                            if let Some(ref mut d) = crate::kernel::dialog::GLOBAL_FILE_DIALOG {
                                if d.is_open {
                                    d.handle_mouse(
                                        mx as i32,
                                        my as i32,
                                        left_click,
                                        screen.width,
                                        screen.height,
                                    );
                                    dialog_handled = true;
                                }
                            }
                        }
                        if dialog_handled {
                            kernel::window_mgr::get_instance().dirty = true;
                        } else if power_modal_visible {
                            if just_pressed {
                                let cx = screen.width / 2;
                                let cy = screen.height / 2;
                                if mx >= cx - 150 && mx <= cx + 150 {
                                    if my >= cy - 60 && my <= cy - 20 {
                                        unsafe {
                                            screen.clear(kernel::draw::Color::BLACK);
                                            screen.draw_string_vector(cx.saturating_sub(250), cy - 10, "System Halted. You can safely turn off your machine.", kernel::draw::Color::WHITE, 24);
                                            screen.flush();
                                            loop {
                                                core::arch::asm!("wfe");
                                            }
                                        }
                                    } else if my >= cy && my <= cy + 40 {
                                        // Reboot using Watchdog
                                        unsafe {
                                            let rstc = 0x3F10_001C as *mut u32;
                                            let wdog = 0x3F10_0024 as *mut u32;
                                            core::ptr::write_volatile(wdog, 0x5A00_0000 | 10);
                                            let mut rstc_val = core::ptr::read_volatile(rstc);
                                            rstc_val = (rstc_val & 0xFFFF_FFCF) | 0x5A00_0020;
                                            core::ptr::write_volatile(rstc, rstc_val);
                                            loop {
                                                core::arch::asm!("wfe");
                                            }
                                        }
                                    } else if my >= cy + 60 && my <= cy + 100 {
                                        power_modal_visible = false;
                                        let mut wm = kernel::window_mgr::get_instance();
                                        wm.dirty = true;
                                    }
                                }
                            }
                        } else {
                            let mut wm_handled = false;
                            if login_mgr.is_unlocked() {
                                let mut wm = kernel::window_mgr::get_instance();
                                wm_handled = wm.handle_mouse(
                                    mx as i32,
                                    my as i32,
                                    left_click,
                                    right_click,
                                    tablet_wheel,
                                    screen,
                                );
                                if wm.terminal_focused && tablet_wheel != 0 {
                                    terminal.scroll(tablet_wheel * 2);
                                }
                                // ターミナルランチャー: クリックでアプリ起動
                                if wm.terminal_focused && just_pressed {
                                    if let Some(app_name) = terminal.handle_click(mx as i32, my as i32) {
                                        let cmd = alloc::format!("os.run(\"{}\")", app_name);
                                        if let Some(ctx) = &terminal.context {
                                            ctx.cmd_queue.push(cmd);
                                        }
                                        terminal.print_line(alloc::format!("> run {}", app_name));
                                        terminal.dirty = true;
                                        wm.dirty = true;
                                    }
                                }
                            }

                            if wm_handled {
                                sysmon_pane.handle_mouse(-1, -1, left_click);
                            } else {
                                let sysmon_handled =
                                    sysmon_pane.handle_mouse(mx as i32, my as i32, left_click);
                                if sysmon_pane.wants_power_menu {
                                    power_modal_visible = true;
                                    sysmon_pane.wants_power_menu = false;
                                    let mut wm = kernel::window_mgr::get_instance();
                                    wm.dirty = true;
                                }
                                if !sysmon_handled && !login_mgr.is_unlocked() {
                                    login_mgr.handle_mouse_input(mx, my, left_click, tablet_wheel);
                                }
                            }
                        }
                        input_state = 0;
                    }
                    _ => input_state = 0,
                }
            }

            if let Some(kbd_u32) = kbd_data {
                let val = kbd_u32 as u8;
                // 【2026-09-08 一時診断】かなキーがゲストへ届いているかの確認用。
                // QEMU の cocoa がどの qcode で送るかはバージョン依存で、
                // 届いていないのか・届いているが処理されていないのかを
                // ログでしか切り分けられない。原因特定後に削除すること。
                {
                    static KEY_TRACE: core::sync::atomic::AtomicU32 =
                        core::sync::atomic::AtomicU32::new(0);
                    if KEY_TRACE.fetch_add(1, core::sync::atomic::Ordering::Relaxed) < 64 {
                        crate::warn!(
                            "[KBD][TRACE] raw=0x{:02X} make={} code=0x{:02X}",
                            val,
                            (val & 0x80) == 0,
                            val & 0x7F
                        );
                    }
                }
                if let Some(ev) = kbd.decode(val) {
                    process_key_event(
                        ev,
                        1,
                        &mut terminal,
                        &mut kbd,
                        &mut ime_state,
                        &mut login_mgr,
                        &mut sysmon_pane,
                        &mut power_modal_visible,
                        screen,
                        &shortcut_mgr,
                    );

                    // 修飾キー（Ctrl/Alt/Shift）の押下・解放でガイドバーを更新するため再描画
                    match ev.keycode {
                        0x1D | 0x38 | 0x2A | 0x36 => {
                            kernel::window_mgr::get_instance().dirty = true;
                        }
                        _ => {}
                    }

                    unsafe {
                        if ev.pressed {
                            if REPEAT_STATE.active_keycode != ev.keycode {
                                REPEAT_STATE.active_keycode = ev.keycode;
                                let now = kernel::timer::get_system_time_ms();
                                REPEAT_STATE.press_start_ms = now;
                                REPEAT_STATE.last_repeat_ms = now;
                                REPEAT_STATE.stage = 0;
                            }
                        } else {
                            if REPEAT_STATE.active_keycode == ev.keycode {
                                REPEAT_STATE.active_keycode = 0;
                            }
                        }
                    }
                }
            }
        }

        if !processed_any {
            // INPUT_FIFO にデータがない場合、キーリピート判定を行う
            let mut key_event_to_process: Option<kernel::keyboard::KeyEvent> = None;
            let mut repeat_count: u32 = 1;
            unsafe {
                if REPEAT_STATE.active_keycode != 0 {
                    let now = kernel::timer::get_system_time_ms();
                    let elapsed = now.saturating_sub(REPEAT_STATE.press_start_ms);
                    let since_last_repeat = now.saturating_sub(REPEAT_STATE.last_repeat_ms);

                    // 第二リピートの条件判定
                    if elapsed >= REPEAT_PARAMS.second_delay_ms as u64 {
                        if since_last_repeat >= REPEAT_PARAMS.second_interval_ms as u64 {
                            REPEAT_STATE.stage = 2;
                            REPEAT_STATE.last_repeat_ms = now;
                            key_event_to_process = Some(kernel::keyboard::KeyEvent {
                                keycode: REPEAT_STATE.active_keycode,
                                pressed: true,
                            });
                            repeat_count = REPEAT_PARAMS.second_repeat_count;
                        }
                    }
                    // 第一リピートの条件判定
                    else if elapsed >= REPEAT_PARAMS.first_delay_ms as u64
                        && since_last_repeat >= REPEAT_PARAMS.first_interval_ms as u64
                    {
                        REPEAT_STATE.stage = 1;
                        REPEAT_STATE.last_repeat_ms = now;
                        key_event_to_process = Some(kernel::keyboard::KeyEvent {
                            keycode: REPEAT_STATE.active_keycode,
                            pressed: true,
                        });
                        repeat_count = 1;
                    }
                }
            }

            if let Some(ev) = key_event_to_process {
                process_key_event(
                    ev,
                    repeat_count,
                    &mut terminal,
                    &mut kbd,
                    &mut ime_state,
                    &mut login_mgr,
                    &mut sysmon_pane,
                    &mut power_modal_visible,
                    screen,
                    &shortcut_mgr,
                );
            }

            let ticks = crate::kernel::timer::get_ticks();
            static mut NIC_DEBUG_DONE: bool = false;
            if ticks == 500 && unsafe { !NIC_DEBUG_DONE } {
                unsafe {
                    NIC_DEBUG_DONE = true;
                }
                crate::info!("[NET] === HEADLESS 5 SEC NIC DEBUG ===");
                crate::info!("[NET] {}", crate::kernel::net::nic_debug_info());
                crate::info!("[NET] === END NIC DEBUG ===");
            }

            crate::kernel::scheduler::yield_now();
        }

        // ---------------------------------------------------------
        // 描画処理 (最大 60 FPS 制約 + ダブルバッファリング)
        // ---------------------------------------------------------
        let now = crate::kernel::timer::get_system_time_ms();
        if now.saturating_sub(last_render_time) >= 16 {
            last_render_time = now;

            let mouse_moved = mx != mouse_obj.x || my != mouse_obj.y;
            
            // --- マウスクリック状態のアニメーション更新 ---
            let was_clicked = mouse_obj.is_clicked;
            mouse_obj.is_clicked = pwr_last_mouse_btn;
            if pwr_last_mouse_btn {
                if !was_clicked {
                    // 押した瞬間にアニメーション開始
                    mouse_obj.click_frame = 1;
                } else if mouse_obj.click_frame < 10 {
                    mouse_obj.click_frame += 1;
                }
            } else {
                mouse_obj.click_frame = 0;
            }
            let mouse_animating = mouse_obj.click_frame > 0 && mouse_obj.click_frame < 10;

            // CSS `cursor: text` の要素上にマウスがあれば矢印の代わりに I-beam を描く
            // （前フレームのブラウザ描画結果を参照する1フレーム遅延だが、60FPS では
            // 体感できない）。
            mouse_obj.is_text_cursor = apps::browser::hovered_cursor_is_text();

            let now_ticks = crate::kernel::timer::get_ticks();
            let sysmon_needs_update = now_ticks.saturating_sub(last_sysmon_ticks) >= 1000;
            let timer_redraw = kernel::window_mgr::get_instance().needs_timer_redraw();
            let browser_active_render = apps::browser::needs_render();

            // --- ダーティ矩形の収集パイプライン ---
            let mut wm = kernel::window_mgr::get_instance();

            // マウスカーソルはコンテンツのダーティ矩形とは独立して処理する。
            // マウス移動だけで全コンポーネントを再描画する無駄を防ぐ。

            // 2. 各種コンポーネントの更新に伴うダーティ登録
            let is_unlocked = login_mgr.is_unlocked();
            if is_unlocked && !was_unlocked {
                wm.add_dirty_rect(kernel::window_mgr::Rect::new(
                    0,
                    0,
                    screen.width,
                    screen.height,
                ));
                was_unlocked = true;
            }

            if !is_unlocked {
                if login_mgr.needs_redraw || first_render {
                    wm.add_dirty_rect(kernel::window_mgr::Rect::new(
                        0,
                        0,
                        screen.width,
                        screen.height,
                    ));
                }
            } else {
                // 非同期 Aura 実行の結果が届いていたら再描画を促す（draw() が result_queue を
                // 消費してログ化するため。これが無いと次のキー入力まで結果が表示されない）。
                if terminal.has_pending_results() {
                    terminal.dirty = true;
                }
                if terminal.dirty || terminal.input_dirty {
                    // ターミナルとタブバーの範囲をダーティ登録
                    wm.add_dirty_rect(kernel::window_mgr::Rect::new(
                        0,
                        0,
                        tab_w + center_w,
                        content_h,
                    ));
                }
                if sysmon_needs_update {
                    // システムモニターの範囲をダーティ登録
                    wm.add_dirty_rect(kernel::window_mgr::Rect::new(
                        sysmon_x as i32,
                        0,
                        sysmon_w,
                        content_h,
                    ));
                }
                if wm.dirty {
                    // アクティブな全ウィンドウの現在の矩形をダーティ登録
                    let rects: alloc::vec::Vec<_> = wm
                        .windows
                        .iter()
                        .filter(|win| win.workspace == wm.active_workspace && !win.is_minimized)
                        .map(|win| {
                            kernel::window_mgr::Rect::new(win.x, win.y, win.width, win.height)
                        })
                        .collect();
                    for r in rects {
                        wm.add_dirty_rect(r);
                    }
                }
                // ProxyApp の shared_buffer 更新通知を確認し、更新があれば矩形をダーティ登録する。
                // これにより needs_timer_redraw が false のアプリでも描画が反映される。
                {
                    let rects: alloc::vec::Vec<_> = wm
                        .windows
                        .iter()
                        .filter(|win| {
                            win.workspace == wm.active_workspace
                                && !win.is_minimized
                                && win.app.get_buffer_updated_flag()
                                    .map(|flag| {
                                        // Ordering::Acquire で読み取り、app_runner の Release と同期
                                        flag.swap(false, core::sync::atomic::Ordering::Acquire)
                                    })
                                    .unwrap_or(false)
                        })
                        .map(|win| {
                            kernel::window_mgr::Rect::new(win.x, win.y, win.width, win.height)
                        })
                        .collect();
                    for r in rects {
                        wm.add_dirty_rect(r);
                    }
                }
                if timer_redraw {
                    // タイマー再描画要求があるウィンドウの矩形をダーティ登録
                    let rects: alloc::vec::Vec<_> = wm
                        .windows
                        .iter()
                        .filter(|win| {
                            win.workspace == wm.active_workspace
                                && !win.is_minimized
                                && win.app.needs_timer_redraw()
                        })
                        .map(|win| {
                            kernel::window_mgr::Rect::new(win.x, win.y, win.width, win.height)
                        })
                        .collect();
                    for r in rects {
                        wm.add_dirty_rect(r);
                    }
                }
                if browser_active_render {
                    // ブラウザ表示ウィンドウの矩形をダーティ登録
                    let rects: alloc::vec::Vec<_> = wm
                        .windows
                        .iter()
                        .filter(|win| {
                            win.workspace == wm.active_workspace
                                && !win.is_minimized
                                && (win.app.name() == "Browser" || win.app.name() == "WebBrowser")
                        })
                        .map(|win| {
                            kernel::window_mgr::Rect::new(win.x, win.y, win.width, win.height)
                        })
                        .collect();
                    for r in rects {
                        wm.add_dirty_rect(r);
                    }
                }
                if ime_state.mode == crate::kernel::ime::ImeMode::Japanese && ime_state.composing {
                    // IME表示エリアの登録（画面下部）
                    let y = screen.height.saturating_sub(44);
                    wm.add_dirty_rect(kernel::window_mgr::Rect::new(
                        0,
                        y as i32 - 250,
                        screen.width,
                        300u32,
                    ));
                }
                if power_modal_visible {
                    let cx = screen.width / 2;
                    let cy = screen.height / 2;
                    wm.add_dirty_rect(kernel::window_mgr::Rect::new(
                        cx as i32 - 180,
                        cy as i32 - 110,
                        360u32,
                        220u32,
                    ));
                }
            }

            if first_render {
                wm.add_dirty_rect(kernel::window_mgr::Rect::new(
                    0,
                    0,
                    screen.width,
                    screen.height,
                ));
            }
            first_render = false;

            // 包含バウンディングボックスの算出
            //
            // 【2026-08-01計測】ブラウザのゲート `needs_render()` は一度も
            // true にならないのに全画面描画が 100 回走っている。
            // ここで登録されているダーティ矩形が原因なので、
            // **何個の矩形がどれだけの面積を要求しているか**を記録する。
            // 合体後の矩形の中は `screen.clear` されるため、
            // 個別矩形でウィンドウを間引くと窓が消える。まず現状を測る。
            {
                static LAST: core::sync::atomic::AtomicUsize =
                    core::sync::atomic::AtomicUsize::new(0);
                let n = wm.dirty_rects.len();
                if n > 0 {
                    let c = LAST.fetch_add(1, core::sync::atomic::Ordering::Relaxed);
                    // 前半だけ見ると「HTML 取得中のスピナー」しか映らない。
                    // 高価な全画面描画は読み込み完了後に起きるので、
                    // 間引いて後半まで満遍なく記録する。
                    if c < 4 || c.is_multiple_of(25) {
                        let mut s = alloc::string::String::new();
                        for r in wm.dirty_rects.iter().take(6) {
                            s.push_str(&alloc::format!("({},{} {}x{}) ", r.x, r.y, r.w, r.h));
                        }
                    }
                }
            }
            let dirty_bb = wm.get_dirty_bounding_box(screen.width, screen.height);

            if let Some(rect) = dirty_bb {
                // クリップ領域を設定して描画を最小化
                screen.set_clip(
                    rect.x as u32,
                    rect.y as u32,
                    (rect.x + rect.w as i32) as u32,
                    (rect.y + rect.h as i32) as u32,
                );

                if !login_mgr.is_unlocked() {
                    screen.clear(kernel::draw::Color::BLACK);
                    login_mgr.draw(screen);
                } else {
                    let config = crate::kernel::config::get_config();
                    screen.clear(kernel::draw::Color(config.theme.desktop_bg));
                    screen.boxfill(
                        sysmon_x,
                        0,
                        sysmon_x + 1,
                        content_h - 1,
                        kernel::draw::Color(config.theme.active_window_border),
                    );
                    terminal.draw(screen, tab_w as i32, 0, center_w, content_h);

                    // ターミナル用タブの描画（背景レイヤーの左端・バーと重ならない高さ）
                    screen.boxfill(0, 0, 100, content_h, kernel::draw::Color(config.theme.tab_area_bg));
                    screen.boxfill(99, 0, 100, content_h, kernel::draw::Color(config.theme.tab_area_border)); // 境界線
                    screen.draw_string_vector(10, 15, "TABS", kernel::draw::Color(config.theme.tab_inactive_fg), 14);
                    screen.boxfill(10, 35, 90, 36, kernel::draw::Color(config.theme.tab_area_border));

                    let tab_bg = kernel::draw::Color(config.theme.tab_active_bg); // Active
                    let tab_fg = kernel::draw::Color(config.theme.tab_active_fg); // Active
                    screen.boxfill(5, 45, 95, 73, tab_bg);
                    screen.draw_string_vector(10, 51, "[1]", tab_fg, 12);
                    screen.draw_string_vector(35, 51, "Shell", tab_fg, 10);
                    sysmon_pane.draw(screen);
                    wm.draw_all(screen);

                    if ime_state.mode == crate::kernel::ime::ImeMode::Japanese
                        && ime_state.composing
                    {
                        let text = if ime_state.converting {
                            alloc::format!(" {} ", ime_state.get_display_text())
                        } else {
                            alloc::format!(" {}_{} ", ime_state.kana_buf, ime_state.romaji_buf)
                        };
                        // 文字幅を推定: CJK文字 = 16px, ASCII = 9px (size16ベクトルフォント基準)
                        let text_px: u32 = text
                            .chars()
                            .map(|c| if (c as u32) > 127 { 16u32 } else { 9u32 })
                            .sum();
                        let w = (text_px + 24).clamp(60, sysmon_x.saturating_sub(20));
                        let h = 30u32;
                        // テキストボックスを画面右端に合わせて配置 (sysmon の左端より左)
                        let x = sysmon_x.saturating_sub(w + 20);
                        let y = screen.height.saturating_sub(44);
                        screen.boxfill(x, y, x + w, y + h, kernel::draw::Color(config.theme.ime_bg));

                        let line_color = kernel::draw::Color(config.theme.ime_border);
                        screen.boxfill(x, y, x + w, y + 2, line_color);
                        screen.draw_string_vector(
                            x + 10,
                            y + 7,
                            &text,
                            kernel::draw::Color(config.theme.ime_text),
                            16,
                        );

                        // 候補ウィンドウ (変換中のみ)
                        if ime_state.converting && !ime_state.candidates.is_empty() {
                            let c_w = 220u32;
                            let c_h = ime_state.candidates.len() as u32 * 25 + 10;
                            let c_x_right = x + w;
                            let c_x = c_x_right.saturating_sub(c_w);
                            let c_y = if y >= c_h + 5 { y - c_h - 5 } else { 0 };
                            let max_rows = ((y.saturating_sub(c_y)) / 25).max(1) as usize;
                            let visible_cands = ime_state.candidates.len().min(max_rows);

                            screen.boxfill(
                                c_x,
                                c_y,
                                c_x + c_w,
                                c_y + visible_cands as u32 * 25 + 10,
                                kernel::draw::Color(config.theme.ime_bg),
                            );
                            screen.boxfill(
                                c_x,
                                c_y,
                                c_x + c_w,
                                c_y + 2,
                                kernel::draw::Color(config.theme.ime_border),
                            );

                            for (i, cand) in
                                ime_state.candidates.iter().enumerate().take(visible_cands)
                            {
                                let item_y = c_y + 5 + (i as u32 * 25);
                                if i == ime_state.selected_idx {
                                    screen.boxfill(
                                        c_x + 2,
                                        item_y,
                                        c_x + c_w - 2,
                                        item_y + 24,
                                        kernel::draw::Color(config.theme.tab_area_border),
                                    );
                                }
                                let disp = alloc::format!("{}. {}", i + 1, cand);
                                screen.draw_string_vector(
                                    c_x + 12,
                                    item_y + 5,
                                    &disp,
                                    kernel::draw::Color(config.theme.ime_text),
                                    14,
                                );
                            }
                        }
                    }

                    if sysmon_needs_update {
                        last_sysmon_ticks = now_ticks;
                    }

                    if power_modal_visible {
                        let cx = screen.width / 2;
                        let cy = screen.height / 2;

                        // モーダル背景
                        let mw = 360;
                        let mh = 220;
                        let mx0 = cx - mw / 2;
                        let my0 = cy - mh / 2;
                        screen.boxfill(
                            mx0,
                            my0,
                            mx0 + mw,
                            my0 + mh,
                            kernel::draw::Color(config.theme.login_dialog_bg),
                        );
                        screen.boxfill(
                            mx0,
                            my0,
                            mx0 + mw,
                            my0 + 3,
                            kernel::draw::Color(config.theme.focus_highlight),
                        ); // 上部ライン
                        screen.draw_string_vector(
                            mx0 + 20,
                            my0 + 15,
                            "Power Options",
                            kernel::draw::Color(config.theme.login_text_fg),
                            20,
                        );

                        // Shutdown button
                        screen.boxfill(
                            cx - 150,
                            cy - 60,
                            cx + 150,
                            cy - 20,
                            kernel::draw::Color(config.theme.focus_highlight),
                        );
                        screen.draw_string_vector(
                            cx - 45,
                            cy - 52,
                            "Shutdown",
                            kernel::draw::Color::WHITE,
                            16,
                        );

                        // Reboot button
                        screen.boxfill(
                            cx - 150,
                            cy,
                            cx + 150,
                            cy + 40,
                            kernel::draw::Color(config.theme.button_active_bg),
                        );
                        screen.draw_string_vector(
                            cx - 35,
                            cy + 8,
                            "Reboot",
                            kernel::draw::Color::WHITE,
                            16,
                        );

                        // Cancel button
                        screen.boxfill(
                            cx - 150,
                            cy + 60,
                            cx + 150,
                            cy + 100,
                            kernel::draw::Color(config.theme.button_bg),
                        );
                        screen.draw_string_vector(
                            cx - 35,
                            cy + 68,
                            "Cancel",
                            kernel::draw::Color(config.theme.button_fg),
                            16,
                        );
                    }
                }

                // 画面最下部のファンクションキー・ガイドバー（全幅・常時表示）
                let mods = kernel::fn_bar::ModState {
                    ctrl: kbd.ctrl_pressed,
                    alt: kbd.alt_pressed,
                    shift: kbd.shift_pressed,
                };
                kernel::fn_bar::draw(screen, mods);

                // クリップ領域をクリア
                screen.clear_clip();
            }

            // --- マウスカーソル更新 + VRAM転送 ---
            // コンテンツ変更（dirty_bb）とマウスカーソル更新を独立して処理する。
            // マウスだけ動いた場合でも全コンポーネント再描画を回避できる。
            let has_content_change = dirty_bb.is_some();
            let need_vsync_sync = screen.vsync_enabled() && screen.has_pending_vsync_sync();
            if has_content_change || mouse_moved || mouse_animating || need_vsync_sync {
                if screen.vsync_enabled() {
                    // VSync ページフリップ: カーソル合成→ダーティ領域だけ部分フリップ。
                    if mouse_moved || mouse_animating {
                        mouse_obj.move_to(screen, mx, my);
                    }
                    let content = dirty_bb.map(|r| {
                        (
                            r.x.max(0) as u32,
                            r.y.max(0) as u32,
                            (r.x + r.w as i32).max(0) as u32,
                            (r.y + r.h as i32).max(0) as u32,
                        )
                    });
                    screen.flush_dirty_pageflip(content, &mouse_obj);
                } else {
                    // シングルバッファ: 部分転送で最小限の VRAM 書き込み。

                    // 1. マウスが動いた、またはアニメーション中の場合、古い位置のカーソル残像を消す
                    //    （バックバッファにはカーソルがないので、flush_rect で復元される）
                    if mouse_moved || mouse_animating {
                        // アニメーション中はスパークが広がるため、少し広めにクリアする
                        let clear_pad = 8;
                        screen.flush_rect(
                            mouse_obj.x.saturating_sub(clear_pad),
                            mouse_obj.y.saturating_sub(clear_pad),
                            mouse_obj.x + kernel::draw::Mouse::SIZE + clear_pad * 2,
                            mouse_obj.y + kernel::draw::Mouse::SIZE + clear_pad * 2,
                        );
                    }

                    // 2. コンテンツが変更された領域を VRAM に部分転送
                    if let Some(rect) = dirty_bb {
                        screen.flush_rect(
                            rect.x as u32,
                            rect.y as u32,
                            (rect.x + rect.w as i32) as u32,
                            (rect.y + rect.h as i32) as u32,
                        );
                    }

                    // 3. マウス位置を更新してカーソルを直接 VRAM に描画
                    if mouse_moved {
                        mouse_obj.move_to(screen, mx, my);
                    }
                    screen.draw_mouse_direct(&mouse_obj);
                }
            }

            // ダーティ矩形のクリア
            wm.clear_dirty_rects();
        }

        // フェアネス: 入力が連続している間（processed_any=true で上の yield を通らない）でも、
        // 毎反復で必ず一度スケジューラへ譲渡する。これをしないと連続入力中にメインループが
        // ビジースピンしてバックグラウンドスレッド（画像/ページ取得など）を飢えさせ、CPU を
        // 食い潰してフリーズ感の原因になる。
        crate::kernel::scheduler::yield_now();
    }
}

fn process_key_event(
    ev: kernel::keyboard::KeyEvent,
    repeat_count: u32,
    terminal: &mut crate::apps::terminal::Terminal,
    kbd: &mut crate::kernel::keyboard::Keyboard,
    ime_state: &mut crate::kernel::ime::ImeState,
    login_mgr: &mut crate::apps::login::LoginManager,
    sysmon_pane: &mut kernel::window::SystemMonitorPane,
    _power_modal_visible: &mut bool,
    screen: &kernel::draw::Screen,
    shortcut_mgr: &crate::kernel::shortcut_manager::ShortcutManager,
) {
    for _ in 0..repeat_count {
        let mut wm = kernel::window_mgr::get_instance();
        let active_ws = wm.active_workspace;

        // 0. ESC キーによるプロセスリスト/ターミナルのフォーカス絶対切り替え
        if ev.keycode == 0x01 && ev.pressed {
            if ime_state.composing {
                ime_state.clear();
                kernel::window_mgr::get_instance().dirty = true;
                continue;
            }
            if !apps::browser::is_active() {
                if wm.active_workspace != 1 {
                    wm.active_workspace = 1;
                    sysmon_pane.focused = true;
                    wm.terminal_focused = false;
                } else {
                    if sysmon_pane.focused {
                        sysmon_pane.focused = false;
                        wm.terminal_focused = true;
                    } else {
                        sysmon_pane.focused = true;
                        wm.terminal_focused = false;
                    }
                }
                wm.dirty = true;
                crate::kernel::audio::play_system_se(crate::kernel::audio::SeType::Apply);
                continue;
            }
        }

        // 1. Altキー (LAlt=0x38) 自体の押下・離鍵判定による遅延ジャンプ制御
        if ev.keycode == 0x38 {
            if kbd.ctrl_pressed {
                // Ctrlが同時に押されている場合は、絶対に遅延ジャンプモードにしない
                wm.alt_hold_mode = false;
                wm.alt_input_buffer.clear();
            } else {
                if ev.pressed {
                    wm.alt_hold_mode = true;
                    wm.alt_input_buffer.clear();
                    wm.dirty = true;
                } else {
                    wm.alt_hold_mode = false;
                    if !wm.alt_input_buffer.is_empty() {
                        if let Ok(target_tab_1based) = wm.alt_input_buffer.parse::<usize>() {
                            let target_idx = target_tab_1based.saturating_sub(1);
                            if let Some(win) = wm.windows.last_mut() {
                                if win.workspace == active_ws && !win.is_minimized {
                                    win.app.switch_tab(target_idx);
                                    wm.dirty = true;
                                }
                            }
                        }
                        wm.alt_input_buffer.clear();
                    }
                    wm.dirty = true;
                }
            }
            if !kbd.ctrl_pressed {
                continue; // イベントを消費
            }
        }

        // 2. Altホールド遅延実行モード中のキーフック
        if wm.alt_hold_mode && ev.pressed {
            if ev.keycode == 0x0E {
                // Backspace
                wm.alt_input_buffer.pop();
                wm.dirty = true;
                continue;
            } else if ev.keycode == 0x01 {
                // Esc
                wm.alt_input_buffer.clear();
                wm.dirty = true;
                continue;
            } else if let Some(c) = kbd.get_ascii(ev.keycode) {
                if c.is_ascii_digit() {
                    if wm.alt_input_buffer.len() < 2 {
                        wm.alt_input_buffer.push(c);
                        wm.dirty = true;
                    }
                    continue;
                }
            }
        }

        // 3. ショートカット評価エンジンによる処理
        if ev.pressed {
            let mods = crate::kernel::shortcut_manager::Modifiers::new(
                kbd.ctrl_pressed,
                kbd.alt_pressed,
                kbd.shift_pressed,
            );
            let action = shortcut_mgr.evaluate(ev.keycode, mods);

            match action {
                crate::kernel::shortcut_manager::InputAction::SwitchTabRelative(offset) => {
                    if let Some(win) = wm.windows.last_mut() {
                        if win.workspace == active_ws && !win.is_minimized {
                            let total_tabs = win.app.tabs().len();
                            if total_tabs > 0 {
                                let cur_tab = win.app.active_tab() as isize;
                                let next_tab =
                                    (cur_tab + offset).rem_euclid(total_tabs as isize) as usize;
                                win.app.switch_tab(next_tab);
                                wm.dirty = true;
                            }
                        }
                    }
                    continue;
                }
                crate::kernel::shortcut_manager::InputAction::NewTab => {
                    if !wm.terminal_focused {
                        if let Some(win) = wm.windows.last_mut() {
                            if win.workspace == active_ws && !win.is_minimized {
                                let new_tab_idx = win.app.tabs().len();
                                win.app.add_tab();
                                win.spawn_tab_thread(new_tab_idx);
                                wm.dirty = true;
                                crate::kernel::audio::play_system_se(
                                    crate::kernel::audio::SeType::Apply,
                                );
                            }
                        }
                    }
                    continue;
                }
                crate::kernel::shortcut_manager::InputAction::CloseTab => {
                    if !wm.terminal_focused {
                        if let Some(win) = wm.windows.last_mut() {
                            if win.workspace == active_ws && !win.is_minimized {
                                let active_idx = win.app.active_tab();
                                let should_close_window = win.app.close_tab(active_idx);

                                if should_close_window {
                                    wm.windows.pop();
                                    crate::kernel::audio::play_system_se(
                                        crate::kernel::audio::SeType::Close,
                                    );
                                    if wm.windows.is_empty() {
                                        wm.terminal_focused = true;
                                    }
                                } else {
                                    crate::kernel::audio::play_system_se(
                                        crate::kernel::audio::SeType::Apply,
                                    );
                                }
                                wm.dirty = true;
                            }
                        }
                    }
                    continue;
                }

                crate::kernel::shortcut_manager::InputAction::OpenFileDialog => {
                    if !wm.terminal_focused {
                        if let Some(win) = wm.windows.last_mut() {
                            if win.workspace == active_ws && !win.is_minimized {
                                win.app.open_file_dialog();
                                wm.dirty = true;
                            }
                        }
                    }
                    continue;
                }

                crate::kernel::shortcut_manager::InputAction::SaveFile => {
                    if !wm.terminal_focused {
                        if let Some(win) = wm.windows.last_mut() {
                            if win.workspace == active_ws && !win.is_minimized {
                                win.app.save_file();
                                wm.dirty = true;
                            }
                        }
                    }
                    continue;
                }

                crate::kernel::shortcut_manager::InputAction::ToggleFocusSysmonTerminal => {
                    if sysmon_pane.focused {
                        sysmon_pane.focused = false;
                        wm.terminal_focused = true;
                    } else {
                        sysmon_pane.focused = true;
                        wm.terminal_focused = false;
                    }
                    wm.dirty = true;
                    crate::kernel::audio::play_system_se(crate::kernel::audio::SeType::Apply);
                    continue;
                }
                _ => {}
            }
        }
        // 4. IME トグルと入力処理
        if ev.pressed {
            // 【2026-09-08】`0x70`（かな）を追加。
            //
            // QEMU の cocoa 表示は、Mac の かなキーを `lang1`（HID 0x90 →
            // PS/2 0x79 変換）と `katakanahiragana`（HID 0x88 → PS/2 0x70）の
            // どちらで送るかがバージョンによって違う。QEMU 11.1.1 は両方の
            // qcode を持つ。0x70 側に倒れると、こちらのコードが無変更でも
            // かなキーが死ぬ（2026-08-28 の QEMU 更新以降の症状）。
            // 送出側を選べないので、受け側で両方受け付ける。
            // Ctrl+Space: IME の ON/OFF をトグルする。
            //
            // 【2026-09-08 追加】macOS + QEMU 11.1.1 では**かなキーがゲストへ
            // 到達しない**ため、変換/無変換しか無いと日本語入力に入れない。
            // cocoa 表示はかなキーのイベントを送らず、VNC 表示は keysym
            // `0xFF25`(Hiragana) を送るものの QEMU 側にスキャンコードが無く
            // 捨てられる（`ja` キーマップに `Hiragana 0x77` の行はあるが、
            // QEMU 内部の keysym 名テーブルが解決できていない）。
            // Mac の JIS キーボードには変換/無変換キー自体が無いので、
            // 確実に届く組み合わせへ退避させる。
            // Windows 環境の変換/無変換は従来どおり残してある。
            if ev.keycode == 0x39 && kbd.ctrl_pressed {
                let to_japanese = ime_state.mode != crate::kernel::ime::ImeMode::Japanese;
                ime_state.toggle_mode(to_japanese);
                kernel::window_mgr::get_instance().dirty = true;
                continue;
            }
            // かなキー。PS/2 では 0x70(カタカナひらがな) と 0x77(ひらがな) の
            // 二系統があり、どちらで届くかは QEMU のキーマップ次第。
            if ev.keycode == 0x79 || ev.keycode == 0x70 || ev.keycode == 0x77 {
                // 変換キー / かなキー
                ime_state.toggle_mode(true);
                kernel::window_mgr::get_instance().dirty = true;
                continue;
            } else if ev.keycode == 0x7B {
                // 無変換キー
                ime_state.toggle_mode(false);
                kernel::window_mgr::get_instance().dirty = true;
                continue;
            }

            if ime_state.mode == crate::kernel::ime::ImeMode::Japanese {
                let mut wm = kernel::window_mgr::get_instance();
                if ev.keycode == 0x0E {
                    // Backspace
                    if ime_state.composing {
                        ime_state.backspace();
                        wm.dirty = true;
                        continue;
                    }
                } else if ev.keycode == 0x1C {
                    // Enter
                    if let Some(text) = ime_state.handle_enter() {
                        for c in text.chars() {
                            wm.handle_key(0, true, Some(c), false, screen);
                        }
                        wm.dirty = true;
                        continue;
                    }
                } else if ev.keycode == 0x39 {
                    // Space
                    if ime_state.handle_space() {
                        wm.dirty = true;
                        continue;
                    }
                    // 未変換（composing でない）の全角モードでは全角スペースを入力
                    wm.handle_key(0, true, Some('\u{3000}'), false, screen);
                    wm.dirty = true;
                    continue;
                } else if ev.keycode == 0x01 && ime_state.composing {
                    // Escape: 変換キャンセル
                    ime_state.cancel();
                    wm.dirty = true;
                    continue;
                } else if ev.keycode == 0x48 && ime_state.converting {
                    // Up Arrow
                    if !ime_state.candidates.is_empty() {
                        if ime_state.selected_idx > 0 {
                            ime_state.selected_idx -= 1;
                        } else {
                            ime_state.selected_idx = ime_state.candidates.len() - 1;
                        }
                    }
                    wm.dirty = true;
                    continue;
                } else if ev.keycode == 0x50 && ime_state.converting {
                    // Down Arrow
                    if !ime_state.candidates.is_empty() {
                        ime_state.selected_idx =
                            (ime_state.selected_idx + 1) % ime_state.candidates.len();
                    }
                    wm.dirty = true;
                    continue;
                } else if ime_state.converting {
                    // 数字キー 1〜9 で候補を直接選択して確定
                    if let Some(c) = kbd.get_ascii(ev.keycode) {
                        if ('1'..='9').contains(&c) {
                            let n = (c as u8 - b'0') as usize;
                            if let Some(text) = ime_state.select_candidate_by_number(n) {
                                for ch in text.chars() {
                                    wm.handle_key(0, true, Some(ch), false, screen);
                                }
                                wm.dirty = true;
                                continue;
                            }
                        }
                    }
                    // 変換中に英字が来たら確定してから入力
                    if let Some(c) = kbd.get_ascii(ev.keycode) {
                        if c.is_ascii_alphabetic() {
                            if let Some(text) = ime_state.handle_enter() {
                                for ch in text.chars() {
                                    wm.handle_key(0, true, Some(ch), false, screen);
                                }
                            }
                            ime_state.input_char(c);
                            wm.dirty = true;
                            continue;
                        }
                    }
                } else if let Some(c) = kbd.get_ascii(ev.keycode) {
                    if !kbd.ctrl_pressed
                        && !kbd.alt_pressed
                        && (c.is_ascii_alphabetic() || c.is_ascii_punctuation())
                    {
                        ime_state.input_char(c);
                        wm.dirty = true;
                        continue;
                    }
                }
            }
        }

        if ev.pressed {
            if !login_mgr.is_unlocked() {
                if let Some(c) = kbd.get_ascii(ev.keycode) {
                    login_mgr.handle_key_input(c);
                }
            } else if apps::browser::is_active() {
                let b = apps::browser::get_instance();
                if ev.keycode == 0x01 {
                    // Escape key

                    b.engine.active = false;
                    b.engine.dirty = true;
                    terminal.dirty = true;

                    break;
                } else if ev.keycode == 0x48 {
                    // Up Arrow

                    b.engine.scroll(-24);
                } else if ev.keycode == 0x50 {
                    // Down Arrow

                    b.engine.scroll(24);
                } else if ev.keycode == 0x49 {
                    // Page Up: 1ページ分上スクロール
                    b.engine.scroll(-240);
                } else if ev.keycode == 0x51 {
                    // Page Down: 1ページ分下スクロール
                    b.engine.scroll(240);
                }
            } else {
                let mut key_handled = false;
                if sysmon_pane.focused {
                    key_handled = sysmon_pane.handle_key(ev.keycode, kbd.get_ascii(ev.keycode));
                }

                if !key_handled {
                    let mut wm = kernel::window_mgr::get_instance();
                    if wm.handle_key(
                        ev.keycode,
                        ev.pressed,
                        kbd.get_ascii(ev.keycode),
                        kbd.alt_pressed,
                        screen,
                    ) {
                        continue;
                    }

                    // 通常のキー入力 (常にターミナルへ送る)
                    if let Some(c) = kbd.get_ascii(ev.keycode) {
                        if c == '\n' {
                            if kbd.shift_pressed {
                                terminal.input_char('\n');
                            } else {
                                if let Some(cmd_str) = terminal.submit() {
                                    crate::info!("[SYS] === Executing command: {} ===", cmd_str);
                                    crate::apps::terminal::shell::execute_shell_command(
                                        &cmd_str, terminal, kbd,
                                    );
                                    crate::info!("[SYS] === Command execution finished. ===");
                                }
                                break; // 改行確定時はリピート連打を終了
                            }
                        } else if kbd.ctrl_pressed && ev.keycode != 0x0E {
                            // Ctrl押下時は対応するASCII制御文字に変換して送る
                            let ctrl_char = match c.to_ascii_lowercase() {
                                'a' => Some('\x01'),
                                'b' => Some('\x02'),
                                'c' => Some('\x03'),
                                'd' => Some('\x04'),
                                'e' => Some('\x05'),
                                'f' => Some('\x06'),
                                'g' => Some('\x07'),
                                'h' => Some('\x08'),
                                'i' => Some('\t'),
                                'j' => Some('\n'),
                                'k' => Some('\x0B'),
                                'l' => Some('\x0C'),
                                'm' => Some('\r'),
                                'n' => Some('\x0E'),
                                'o' => Some('\x0F'),
                                'p' => Some('\x10'),
                                'q' => Some('\x11'),
                                'r' => Some('\x12'),
                                's' => Some('\x13'),
                                't' => Some('\x14'),
                                'u' => Some('\x15'),
                                'v' => Some('\x16'),
                                'w' => Some('\x17'),
                                'x' => Some('\x18'),
                                'y' => Some('\x19'),
                                'z' => Some('\x1A'),
                                _ => None,
                            };
                            if let Some(cc) = ctrl_char {
                                terminal.input_char(cc);
                            }
                        } else {
                            terminal.input_char(c);
                        }
                    } else {
                        // 特殊キーの処理 (Up/Down/Left/Right/Delete/Home/End)
                        if ev.keycode == 0x48 {
                            // Up Arrow
                            terminal.history_up();
                        } else if ev.keycode == 0x50 {
                            // Down Arrow
                            terminal.history_down();
                        } else if ev.keycode == 0x4B {
                            // Left Arrow
                            terminal.move_cursor_left();
                        } else if ev.keycode == 0x4D {
                            // Right Arrow
                            terminal.move_cursor_right();
                        } else if ev.keycode == 0x53 {
                            // Delete
                            terminal.delete_char();
                        } else if ev.keycode == 0x47 {
                            // Home
                            terminal.move_cursor_to_start();
                        } else if ev.keycode == 0x4F {
                            // End
                            terminal.move_cursor_to_end();
                        } else if ev.keycode == 0x49 {
                            // Page Up: 画面を上方向へスクロール
                            terminal.scroll(-10);
                        } else if ev.keycode == 0x51 {
                            // Page Down: 画面を下方向へスクロール
                            terminal.scroll(10);
                        } else if ev.keycode == 0x0E {
                            // Backspace (Ctrl+H)
                            terminal.input_char('\x08');
                        } else if ev.keycode == crate::kernel::keyboard::KC_KILL_LINE {
                            // Ctrl+K
                            terminal.kill_line();
                        }
                    }
                }
            }
        } else {
            // 離鍵（keyup）: ブラウザがアクティブでアドレスバー非フォーカス時のみ、
            // フォーカス要素へ keyup を発火する（JS の keyup リスナ用）。
            if login_mgr.is_unlocked() && apps::browser::is_active() {
                let b = apps::browser::get_instance();
                if !b.address_bar_focused {
                    b.engine.on_key_up(ev.keycode, kbd.get_ascii(ev.keycode));
                }
            }
        }
    }
}

#[cfg(not(test))]
#[panic_handler]
fn panic(_info: &PanicInfo) -> ! {
    // パニック回復の最重要前処理: このコアが保持中のクリティカルロックを強制解放する。
    // 特にヒープロックは直後の println!(=メモリ確保) が取りに行くため、保持したままだと
    // ハンドラ自身がデッドロックし OS 全体が確保不能になる。NET_LOCK/USB_LOCK は保持したまま
    // プロセスが死ぬとネットワーク/USB が以後デッドロックする。
    let cid = kernel::scheduler::core_id() as i16;
    kernel::allocator::force_release_lock(cid);
    kernel::net::force_release_locks(cid);
    kernel::usb::force_release_locks(cid);
    kernel::fs::force_release_locks(cid);

    let is_critical = kernel::scheduler::is_current_process_critical();
    let name = kernel::scheduler::get_current_process_name().unwrap_or("unknown");
    let pid = kernel::scheduler::get_current_process_id().unwrap_or(0);

    if !is_critical {
        // 【2026-08-25 バグ修正】死ぬ前に取得枠を返す。
        //
        // ここから `scheduler::exit()` で即座に殺すため、
        // ワーカーの `fetch_limit::release()` は**実行されない**。
        // 枠は全体で 8 本しかなく、`os_lib/webp` は
        // 「panic 禁止ポリシーの対象外」と明記されたデコーダなので、
        // 壊れた画像が 8 枚あれば以後フォントも画像も
        // 二度と読み込まれなくなる（しかも黙って止まる）。
        //
        // この関数はロックを取らない（原子変数だけを触る）。
        // 取ると、そのロックを握ったまま死んだ場合に回収自体が固まる。
        os_lib::web_engine::fetch_limit::on_process_died(pid);
        println!(
            "\n=== PROCESS PANIC: Process '{}' (PID: {}) panicked ===",
            name, pid
        );
        println!("{}", _info);
        println!("=====================================================");
        println!(
            "Recovering from process panic: Terminating PID {} and yielding to other processes...",
            pid
        );
        kernel::scheduler::exit();
    } else {
        println!("\n==================================================");
        println!("!!! KERNEL PANIC: CRITICAL PROCESS / KERNEL PANIC !!!");
        println!("==================================================");
        println!("Critical Process '{}' (PID: {}) failed.", name, pid);
        println!("{}", _info);
        loop {
            unsafe {
                core::arch::asm!("wfe");
            }
        }
    }
}

fn mmu_test_process_a() {
    let pt_addr = kernel::scheduler::get_current_page_table().unwrap_or(0);
    if pt_addr != 0 {
        let phys_mem = alloc::vec![0u8; 16384];
        let phys_addr = phys_mem.as_ptr() as u64;
        kernel::mmu::map_page(pt_addr, 0x4000_0000, phys_addr);
        kernel::scheduler::yield_now();

        unsafe {
            let ptr = 0x4000_0000 as *mut u64;
            ptr.write_volatile(0x1111_1111_1111_1111);
        }

        println!("Process A wrote 0x1111... to 0x4000_0000. Sleeping...");
        kernel::scheduler::sleep(100);

        let val = unsafe { (0x4000_0000 as *mut u64).read_volatile() };
        println!("Process A read from 0x4000_0000: {:#X}", val);
    }
    kernel::scheduler::exit();
}

fn mmu_test_process_b() {
    let pt_addr = kernel::scheduler::get_current_page_table().unwrap_or(0);
    if pt_addr != 0 {
        let phys_mem = alloc::vec![0u8; 16384];
        let phys_addr = phys_mem.as_ptr() as u64;
        kernel::mmu::map_page(pt_addr, 0x4000_0000, phys_addr);
        kernel::scheduler::yield_now();

        unsafe {
            let ptr = 0x4000_0000 as *mut u64;
            ptr.write_volatile(0x2222_2222_2222_2222);
        }

        println!("Process B wrote 0x2222... to 0x4000_0000. Sleeping...");
        kernel::scheduler::sleep(50);

        let val = unsafe { (0x4000_0000 as *mut u64).read_volatile() };
        println!("Process B read from 0x4000_0000: {:#X}", val);
    }
    kernel::scheduler::exit();
}

// --------------------------------------------------------------------
// EL0 ユーザープロセス テスト用システムコールラッパーと関数
// --------------------------------------------------------------------
#[no_mangle]
#[link_section = ".user_text"]
fn syscall_print(msg: &str) {
    let ptr = msg.as_ptr() as usize;
    let len = msg.len();
    unsafe {
        core::arch::asm!(
            "svc #0",
            in("x8") 2, // SYS_PRINT
            in("x0") ptr,
            in("x1") len,
            lateout("x0") _, // x0 is modified as return value
        );
    }
}

#[no_mangle]
#[link_section = ".user_text"]
fn syscall_yield() {
    unsafe {
        core::arch::asm!(
            "svc #0",
            in("x8") 0, // SYS_YIELD
            lateout("x0") _,
        );
    }
}

#[no_mangle]
#[link_section = ".user_text"]
fn syscall_exit(code: usize) -> ! {
    unsafe {
        core::arch::asm!(
            "svc #0",
            in("x8") 1, // SYS_EXIT
            in("x0") code,
            options(noreturn)
        );
    }
}

#[no_mangle]
#[link_section = ".user_text"]
fn user_test_normal() {
    syscall_print("Hello from EL0 user space!\n");
    syscall_yield();
    syscall_print("Back to EL0 user space after yield!\n");
    syscall_exit(42);
}

// --- EL0 GUI ウィンドウ ABI スタブ (Phase 4) ---

#[no_mangle]
#[link_section = ".user_text"]
fn syscall3(nr: usize, x0: usize, x1: usize) -> usize {
    let ret: usize;
    unsafe {
        core::arch::asm!(
            "svc #0",
            in("x8") nr,
            inout("x0") x0 => ret,
            in("x1") x1,
        );
    }
    ret
}

/// EL0 パイロット GUI アプリ: 全描画・入力処理を EL0 で行うピクセルデモ。
/// このプロセスが暴走・フォルトしても落ちるのは本プロセスのみで、OS は継続する。
#[no_mangle]
#[link_section = ".user_text"]
pub fn user_pixel_demo() {
    const W: usize = 160;
    const H: usize = 120;

    // ウィンドウ生成（リクエスト構造体はユーザスタック上）
    let title = "EL0 Pixel Demo";
    let req: [usize; 4] = [title.as_ptr() as usize, title.len(), W, H];
    let handle = syscall3(5 /*SYS_WIN_CREATE*/, req.as_ptr() as usize, 0);
    if handle == 0 {
        syscall_print("EL0 demo: window create failed\n");
        syscall_exit(1);
    }

    // ピクセルバッファ（ユーザスタック上・約75KB）
    let mut pixels = [0u32; W * H];
    let mut tick: u32 = 0;
    let mut color_shift: u32 = 0;

    loop {
        // 入力イベントを処理
        let mut ev: u64 = 0;
        while syscall3(
            7, /*SYS_WIN_POLL*/
            handle,
            &mut ev as *mut u64 as usize,
        ) == 1
        {
            let kind = ev >> 56;
            if kind == 3 {
                // ウィンドウが閉じられた → レジストリを掃除してプロセス終了
                syscall3(8 /*SYS_WIN_CLOSE*/, handle, 0);
                syscall_print("EL0 demo: window closed, exiting\n");
                syscall_exit(0);
            }
            if kind == 1 && (ev >> 8) & 1 == 1 {
                // キー押下で配色を切り替え
                color_shift = color_shift.wrapping_add(64);
            }
        }

        // グラデーション + 動くバーを描画（全て EL0 の計算）
        for y in 0..H {
            for x in 0..W {
                let r = ((x * 255 / W) as u32 + color_shift) & 0xFF;
                let g = ((y * 255 / H) as u32) & 0xFF;
                let b = (tick * 2) & 0xFF;
                pixels[y * W + x] = 0xFF00_0000 | (r << 16) | (g << 8) | b;
            }
        }
        let bar_x = (tick as usize) % W;
        for y in 0..H {
            pixels[y * W + bar_x] = 0xFFFFFFFF;
        }

        // カーネルへ提出
        syscall3(6 /*SYS_WIN_BLIT*/, handle, pixels.as_ptr() as usize);

        tick = tick.wrapping_add(1);
        // フレームレート調整（数回 yield して CPU を譲る）
        for _ in 0..3 {
            syscall_yield();
        }
    }
}

#[no_mangle]
#[link_section = ".user_text"]
fn user_test_abort() {
    syscall_print("Starting abort test process in EL0...\n");

    // MMIO領域（0x3F200008: GPIOレジスタなど）への書き込みを試みて Data Abort を発生させる
    // AP設定により EL0 からのアクセスは禁止されているため、Data Abort が発生して
    // rust_data_abort_handler により強制終了されるはず。
    let mmio_ptr = 0x3F20_0008 as *mut u32;
    unsafe {
        core::ptr::write_volatile(mmio_ptr, 0);
    }

    // ここには到達しないはず
    syscall_print("ERROR: Accessed MMIO without abort!\n");
    syscall_exit(99);
}