atmos/kernel/

mmu.rs

// mmu.rs - MMU Configuration for AArch64 with 4KB Pages (Identity Mapping)
#![allow(dead_code)]
extern crate alloc;
use alloc::boxed::Box;

// ページテーブル用メモリの定義 (4KBアラインメント必須)
#[repr(C, align(4096))]
struct PageTables {
    l1_table: [u64; 512],   // L1テーブル (1エントリ1GBをカバー。512エントリで512GB)
    l2_table_0: [u64; 512], // L2テーブル 0
    l2_table_1: [u64; 512], // L2テーブル 1
}

static mut TABLES: PageTables = PageTables {
    l1_table: [0; 512],
    l2_table_0: [0; 512],
    l2_table_1: [0; 512],
};

/// GPU / フレームバッファ / MMIO が始まる物理アドレス。
///
/// ここ以上は Device(uncached) としてマップされる。
/// 通常メモリ（キャッシュ有効）として使ってよいのは**この値未満**だけ。
///
/// 【2026-08-25】この境界は 3 箇所に直書きされていた
/// （`mmu.rs` のマップ判定、`fs/mod.rs` の RAMDisk 上限、
///   `draw.rs` の領域表示）。RAMDisk がヒープ外の物理 RAM を
/// 直接使うようになり、**この値を間違えるとフレームバッファを壊す**。
/// 権威はマップを決めている此処に置き、他はここを参照する。
pub const DEVICE_REGION_START: usize = 0x3800_0000;

/// 恒等マップとMMU保護を有効化します
pub fn init() {
    crate::info!("[MMU] Initializing MMU (4KB Page Size, Identity Mapping)...");

    unsafe {
        // L1, L2 テーブルのクリア
        for i in 0..512 {
            TABLES.l1_table[i] = 0;
            TABLES.l2_table_0[i] = 0;
            TABLES.l2_table_1[i] = 0;
        }

        // 1. L1テーブルにL2テーブルのアドレスを登録
        let l2_phys_addr_0 = &TABLES.l2_table_0 as *const u64 as u64;
        let l2_phys_addr_1 = &TABLES.l2_table_1 as *const u64 as u64;
        TABLES.l1_table[0] = (l2_phys_addr_0 & 0x0000_FFFF_FFFF_F000) | 0b11;
        TABLES.l1_table[1] = (l2_phys_addr_1 & 0x0000_FFFF_FFFF_F000) | 0b11;

        // 2. L2テーブルの構築 (2MBブロックマッピングによる 2GB 恒等マップ)
        for i in 0..1024 {
            let phys_block_addr = (i as u64) * 0x0020_0000;

            let mut desc = phys_block_addr & 0x0000_FFFF_FFFF_F000;
            desc |= 1 << 10; // Access Flag (AF = 1)
            desc |= 3 << 8; // Shareability = Inner Shareable (SH = 0b11)
            desc |= 0 << 6; // AP = Read/Write (AP[2:1] = 0b00) - EL1からはRW可能、EL0は設定次第

            // gpu_mem=128 の RPi3 では GPU/フレームバッファ領域は 0x3800_0000〜0x3FFF_FFFF。
            // フレームバッファがこの範囲に確保され得るため、0x3800_0000 以上を Device(uncached)
            // にしないと CPU のフレームバッファ書き込みが GPU と非コヒーレントになり横線ノイズが出る。
            // （ARM RAM は 0x0000_0000〜0x37FF_FFFF。カーネルヒープもこの範囲内のため安全）
            if phys_block_addr >= DEVICE_REGION_START as u64 {
                // MMIO/VRAM/ローカル割り込み領域
                desc |= 1 << 2; // AttrIndex = 1
                desc |= 1 << 54; // Execute-Never (UXN = 1)
                desc |= 1 << 53; // Privileged Execute-Never (PXN = 1)
                desc |= 0b01; // Type = Block Entry (0b01)
            } else {
                // 通常のRAM領域
                desc |= 0 << 2; // AttrIndex = 0
                desc |= 0b01; // Type = Block Entry (0b01)
            }

            if i < 512 {
                TABLES.l2_table_0[i] = desc;
            } else {
                TABLES.l2_table_1[i - 512] = desc;
            }
        }

        // 3. MAIR_EL1 (Memory Attribute Indirection Register) の設定
        // Attr 0: 0xFF (Normal Memory: Write-Back, Non-transient, Read/Write allocate)
        // Attr 1: 0x04 (Device nGnRE)
        let mair: u64 = 0xFF | (0x04 << 8);
        core::arch::asm!("msr mair_el1, {}", in(reg) mair);

        // 4. TCR_EL1 (Translation Control Register) の設定
        // TG0 = 0b00 (4KB Page Size)
        // ORGN0 = 0b01, IRGN0 = 0b01 (Inner/Outer Write-Back Cacheable)
        // SH0 = 0b11 (Inner Shareable)
        // T0SZ = 25 (仮想アドレス空間を39ビット幅に制限: 64 - 39 = 25. 恒等マップの1GBはL1開始にすることで正しく処理されます)
        // IPS = 0b001 (物理アドレス幅 36ビット)
        let tcr: u64 = (3 << 12)  | // SH0 = Inner Shareable (0b11)
                       (1 << 10)  | // ORGN0 = Outer WB WA
                       (1 << 8)   | // IRGN0 = Inner WB WA
                       25  | // T0SZ = 25
                       (1 << 32); // IPS = 36-bit PA
        core::arch::asm!("msr tcr_el1, {}", in(reg) tcr);

        // 5. TTBR0_EL1 (Translation Table Base Register 0) の設定
        let l1_phys_addr = &TABLES.l1_table as *const u64 as u64;
        core::arch::asm!("msr ttbr0_el1, {}", in(reg) l1_phys_addr);

        // TLB 全体を無効化 (Invalidate TLB)
        core::arch::asm!("tlbi vmalle1is", "dsb sy", "isb", options(nostack));

        // 6. MMU とキャッシュの有効化 (SCTLR_EL1)
        // 最初は M = 1 (MMU Enable) と I = 1 (Instruction Cache Enable) のみ有効化、
        // C = 0 (Data/Unified Cache Disable) は無効にしておくことで、ページテーブル読み込みでのキャッシュ不整合を防ぐ。
        let mut sctlr: u64;
        core::arch::asm!("mrs {}, sctlr_el1", out(reg) sctlr);
        sctlr |= 1 << 0; // M (MMU)
        sctlr &= !(1 << 2); // C (Cache)
        sctlr |= 1 << 12; // I (Instruction Cache)
        core::arch::asm!("msr sctlr_el1, {}", in(reg) sctlr);

        // 命令同期バリアとデータバリアで設定をフラッシュ
        core::arch::asm!("isb", "dsb sy", options(nostack));

        // MMU有効化（かつデータキャッシュ無効）の状態で、ページテーブル全体のキャッシュフラッシュと無効化を確実に実行する
        // (MMU有効時なので、仮想アドレス指定の dc civac が正しく機能する)
        clean_dcache_range(
            &TABLES as *const PageTables as usize,
            core::mem::size_of::<PageTables>(),
        );

        // データキャッシュを有効化
        core::arch::asm!("mrs {}, sctlr_el1", out(reg) sctlr);
        sctlr |= 1 << 2; // C (Cache)
        core::arch::asm!("msr sctlr_el1, {}", in(reg) sctlr);

        // 再度フラッシュ
        core::arch::asm!("isb", "dsb sy", options(nostack));
    }

    crate::info!("[MMU] MMU and Caching successfully enabled!");
}

/// セカンダリコア向けのMMU有効化
pub fn init_secondary() {
    unsafe {
        let mair: u64 = 0xFF | (0x04 << 8);
        core::arch::asm!("msr mair_el1, {}", in(reg) mair);

        // TG0 = 4KB, T0SZ = 25
        let tcr: u64 = (3 << 12) | (1 << 10) | (1 << 8) | 25 | (1 << 32);
        core::arch::asm!("msr tcr_el1, {}", in(reg) tcr);

        let l1_phys_addr = &TABLES.l1_table as *const u64 as u64;
        core::arch::asm!("msr ttbr0_el1, {}", in(reg) l1_phys_addr);

        let mut sctlr: u64;
        core::arch::asm!("mrs {}, sctlr_el1", out(reg) sctlr);
        sctlr |= 1 << 0;
        sctlr &= !(1 << 2); // C (Cache)
        sctlr |= 1 << 12;
        core::arch::asm!("msr sctlr_el1, {}", in(reg) sctlr);

        core::arch::asm!("isb", "dsb sy", options(nostack));

        // データキャッシュを有効化
        core::arch::asm!("mrs {}, sctlr_el1", out(reg) sctlr);
        sctlr |= 1 << 2;
        core::arch::asm!("msr sctlr_el1, {}", in(reg) sctlr);

        core::arch::asm!("isb", "dsb sy", options(nostack));
    }
}

pub fn get_kernel_page_table() -> u64 {
    unsafe { core::ptr::addr_of!(TABLES.l1_table) as *const u64 as u64 }
}

pub fn create_process_page_table() -> u64 {
    get_kernel_page_table()
}

pub fn create_user_page_table() -> u64 {
    create_page_table_internal(false)
}

fn create_page_table_internal(is_kernel: bool) -> u64 {
    unsafe {
        let mut pt = Box::new(PageTables {
            l1_table: [0; 512],
            l2_table_0: [0; 512],
            l2_table_1: [0; 512],
        });

        // 既存のカーネルマップ (TABLES) をコピー
        for i in 0..512 {
            pt.l1_table[i] = TABLES.l1_table[i];
            pt.l2_table_0[i] = TABLES.l2_table_0[i];
            pt.l2_table_1[i] = TABLES.l2_table_1[i];
        }

        // ユーザープロセス用: RAM領域はEL0アクセス許可、MMIO領域はEL0ブロック
        if !is_kernel {
            for i in 0..1024 {
                let phys_block_addr = (i as u64) * 0x0020_0000;
                let table = if i < 512 {
                    &mut pt.l2_table_0
                } else {
                    &mut pt.l2_table_1
                };
                let idx = if i < 512 { i } else { i - 512 };

                if phys_block_addr >= DEVICE_REGION_START as u64 {
                    // MMIO/VRAM/ローカル割り込み領域: EL0からのアクセスを完全にブロック
                    // gpu_mem=128 の GPU/フレームバッファ領域(0x3800_0000〜)を Device(uncached) にし、
                    // CPU 書き込みと GPU スキャンアウトのコヒーレンシを保つ（横線ノイズ対策）。
                    // AP[2:1] = 0b00 (EL1のみ RW, EL0はアクセス不可 → Data Abort 発生)
                    let mut desc = phys_block_addr & 0x0000_FFFF_FFFF_F000;
                    desc |= 1 << 10; // AF
                    desc |= 3 << 8; // SH = Inner Shareable
                    desc |= 0 << 6; // AP[2:1] = 0b00 (EL1 only)
                    desc |= 1 << 2; // AttrIndex = 1 (Device memory)
                    desc |= 1 << 54; // UXN
                    desc |= 1 << 53; // PXN
                    desc |= 0b01; // Block Entry
                    table[idx] = desc;
                } else if phys_block_addr < 0x0060_0000 {
                    // カーネルコード領域（block 0,1 = 0..4MB、.user_text(0x400000)より下）:
                    // カーネルコード・カーネルスタック・例外ベクタテーブル。
                    // 特権（EL1）のみアクセス可能にし、PANやPXNによる例外（ダブルフォルト）を回避。
                    // ※ kernel .text が 2MB を越えて block 1 に伸びたため、block 0 のみでは
                    //   block 1 のカーネルコードが EL0 アクセス可ページのままとなり EL1 実行で
                    //   命令アボートを起こしていた（JSエンジン追加でバイナリ肥大時に顕在化）。
                    let mut desc = phys_block_addr & 0x0000_FFFF_FFFF_F000;
                    desc |= 1 << 10; // AF
                    desc |= 3 << 8; // SH = Inner Shareable
                    desc |= 0 << 6; // AP[2:1] = 0b00 (EL1 only)
                    desc |= 0 << 2; // AttrIndex = 0 (Normal Memory)
                    desc |= 0b01; // Block Entry
                    table[idx] = desc;
                } else {
                    // RAM領域（インデックス 1 以降）: EL0/EL1 ともに RW 可能 (AP[2:1] = 0b01)
                    // ユーザーのコード、スタック、ヒープがRAM上にあるため必須
                    let mut desc = phys_block_addr & 0x0000_FFFF_FFFF_F000;
                    desc |= 1 << 10; // AF
                    desc |= 3 << 8; // SH = Inner Shareable
                    desc |= 1 << 6; // AP[2:1] = 0b01 (EL0/EL1 RW)
                    desc |= 0 << 2; // AttrIndex = 0 (Normal Memory)
                    desc |= 0b01; // Block Entry
                    table[idx] = desc;
                }
            }
        }

        let l2_phys_addr_0 = pt.l2_table_0.as_ptr() as u64;
        let l2_phys_addr_1 = pt.l2_table_1.as_ptr() as u64;
        pt.l1_table[0] = (l2_phys_addr_0 & 0x0000_FFFF_FFFF_F000) | 0b11;
        pt.l1_table[1] = (l2_phys_addr_1 & 0x0000_FFFF_FFFF_F000) | 0b11;

        let raw_ptr = Box::into_raw(pt);

        // ページテーブル全体をフラッシュ
        clean_dcache_range(raw_ptr as usize, core::mem::size_of::<PageTables>());

        raw_ptr as u64
    }
}

pub fn map_page(pt_addr: u64, virt_addr: u64, phys_addr: u64) {
    unsafe {
        let pt = &mut *(pt_addr as *mut PageTables);
        let l2_index_global = (virt_addr / 0x0020_0000) as usize; // 2MBブロック

        let mut desc = phys_addr & 0x0000_FFFF_FFFF_F000;
        desc |= 1 << 10; // Access Flag (AF = 1)
        desc |= 3 << 8; // Shareability = Inner Shareable (SH = 0b11)
        desc |= 0 << 6; // AP = Read/Write (AP[2:1] = 0b00) - EL1
        desc |= 0 << 2; // AttrIndex = 0 (Normal Memory)
        desc |= 0b01; // Type = Block Entry (0b01)

        let entry_addr;
        if l2_index_global < 512 {
            pt.l2_table_0[l2_index_global] = desc;
            entry_addr = &pt.l2_table_0[l2_index_global] as *const u64 as usize;
        } else {
            pt.l2_table_1[l2_index_global - 512] = desc;
            entry_addr = &pt.l2_table_1[l2_index_global - 512] as *const u64 as usize;
        }

        // 更新したL2テーブルエントリのキャッシュラインをDキャッシュから物理メモリへ確実にフラッシュする
        clean_dcache_range(entry_addr, 8);
    }
}

/// データキャッシュの指定された範囲を Point of Coherency (DDR 物理メモリ) まで確実にクリーン（フラッシュ）します
pub fn clean_dcache_range(addr: usize, size: usize) {
    let cache_line_size = 64; // Cortex-A53 の標準キャッシュラインサイズ (64バイト)
    let start = addr & !(cache_line_size - 1);
    let end = addr + size;
    let mut current = start;

    while current < end {
        unsafe {
            core::arch::asm!(
                "dc civac, {}",
                in(reg) current,
                options(nostack)
            );
        }
        current += cache_line_size;
    }

    unsafe {
        core::arch::asm!("dsb sy", "isb", options(nostack));
    }
}

pub fn invalidate_dcache_range(addr: usize, size: usize) {
    let cache_line_size = 64; // Cortex-A53
    let start = addr & !(cache_line_size - 1);
    let end = addr + size;
    let mut current = start;

    while current < end {
        unsafe {
            core::arch::asm!(
                "dc ivac, {}",
                in(reg) current,
                options(nostack)
            );
        }
        current += cache_line_size;
    }

    unsafe {
        core::arch::asm!("dsb sy", "isb", options(nostack));
    }
}