atmos/kernel/fs/

mod.rs

//! SylFS: Copy-on-Write・ラベル指向の頑健なファイルシステム。
//!
//! 特徴（`spec/README.md`「ファイル管理」参照）:
//! - **Copy-on-Write**: 書き込みは新しいセクタへ行い、電源断でも最後の整合状態へ戻れる
//! - **2 重化**: 全データをミラーリングし、片系故障時は自動復旧（[`block::MirroredBlockDevice`]）
//! - **B-tree インデックス**（[`btree::CowBTree`]）: ラベル・名前・日時の高速検索
//! - **エクステント方式**（[`Extent`]）: NTFS の "runs" 同様、連続領域を1エントリで表現し
//!   ファイルサイズの実質上限を撤廃（2026-07-26 導入）
//! - **チェックサム**（[`checksum`]）による自己修復
//!
//! サブモジュール: [`storage_policy`]（保存方針）, [`block`]（ミラー化ブロックデバイス）,
//! [`btree`]（COW B-tree）, [`checksum`]（CRC 検証）。
// fs/mod.rs - SylFS: Copy-on-Write Label-based Robust File System
#![allow(dead_code)]
#![allow(static_mut_refs)]
use crate::println;

pub mod storage_policy;
pub mod block;
pub mod btree;
pub mod checksum;

extern crate alloc;
use alloc::boxed::Box;
use alloc::vec::Vec;

use block::{MirroredBlockDevice, RAMDisk, DATA_SIZE_PER_SECTOR};
use btree::CowBTree;
use core::ptr::null_mut;

pub fn fnv1a_128(data: &[u8]) -> [u8; 16] {
    let mut hash: u128 = 0x6c62272e07bb014262b821756295c58d;
    for &b in data {
        hash ^= b as u128;
        hash = hash.wrapping_mul(0x0000000001000000000000000000013B);
    }
    hash.to_le_bytes()
}

/// ファイルが占めるセクタ範囲を「開始セクタ + 連続数」で表す。
///
/// 【2026-07-26 設計変更】従来はセクタ番号を 1 個ずつ列挙する方式
/// （直接ポインタ 44 本 ≈ 22KB、多段間接を足しても 8.3MB）だったため、
/// ファイルサイズに厳しい上限があった。NTFS の "runs" / exFAT と同じ
/// **エクステント方式**へ変更する。連続領域なら 1 エントリで
/// 最大 2^64 セクタを表現できるため、ポインタ列挙のような容量上限が消える。
#[repr(C, packed)]
#[derive(Clone, Copy, Default)]
pub struct Extent {
    /// 開始セクタ番号。
    pub start: u64,
    /// 連続セクタ数（0 なら未使用エントリ）。
    pub count: u64,
}

/// メタデータ 1 セクタに直接持てるエクステント数。
/// filename(128)+label(64)+size(8)+extent_count(4)+overflow(8)+16*N <= 508 → N <= 18。
const MAX_INLINE_EXTENTS: usize = 18;

/// 溢れたエクステントを格納する 1 セクタに入るエントリ数。
/// 先頭 8 バイトを「次の溢れセクタ番号」に使い、残りをエントリに充てる。
const EXTENTS_PER_OVERFLOW_SECTOR: usize = (DATA_SIZE_PER_SECTOR - 8) / 16;

const SUPERBLOCK_SECTOR: usize = 0;
const BITMAP_START_SECTOR: u32 = 1;
/// 1 ビットマップセクタが管理できるセクタ数（508 バイト × 8 ビット）。
const BITS_PER_BITMAP_SECTOR: u64 = (DATA_SIZE_PER_SECTOR as u64) * 8;

/// フォーマット時のビットマップ領域サイズ（セクタ数）を、実際のデバイス容量から求める。
///
/// 【2026-07-26】従来は `const BITMAP_SECTORS: u32 = 4` とハードコードされており、
/// 管理できるのは 4 × 508 × 8 = 16,256 セクタ ≈ **8.3MB だけ**だった。
/// `sdcard.img` が 1GB あってもその 99% 以上が使われず、
/// 「ファイル 1 個が 22KB まで」という制限以前に**ファイルシステム全体が
/// 8MB しか無い**という状態だった。デバイスの総セクタ数から必要な
/// ビットマップ長を算出することで、ボリューム容量の上限を撤廃する。
fn bitmap_sectors_for(total_sectors: u64) -> u64 {
    total_sectors.div_ceil(BITS_PER_BITMAP_SECTOR).max(1)
}

pub const SYLFS_MAGIC: &[u8; 8] = b"SYLFS\0\0\0";

/// ディスク上の Superblock 構造 (サイズ 24 バイト)
#[repr(C, packed)]
#[derive(Clone, Copy)]
pub struct Superblock {
    pub magic: [u8; 8],
    pub version: u32,
    pub root_sector: u32, // B-Tree インデックスのルート
    pub bitmap_start: u32,
    pub bitmap_sectors: u32,
}

/// ディスク上のファイルメタデータ (サイズ 168 バイト)
#[repr(C, packed)]
#[derive(Clone, Copy)]
pub struct FileMetadata {
    /// ファイル名/パス (UTF-8, NUL終端)。
    /// 【2026-07-26】エクステント領域を確保するため 256→128 バイトへ縮小した。
    /// 本 FS のパスは `/cache/browser/<host>/<hash>` 形式などで 128 バイトあれば足りる。
    pub filename: [u8; 128],
    pub label_data: [u8; 64], // ラベル一覧（カンマ区切り, UTF-8, NUL終端）
    /// ファイルサイズ（バイト）。u32 では 4GB で頭打ちになるため u64 とした。
    pub size: u64,
    /// 有効なエクステントの総数（インライン＋溢れ分の合計）。
    pub extent_count: u32,
    /// 溢れたエクステントを格納するセクタのチェーン先頭（0 なら無し）。
    /// 断片化が激しくインライン 18 本に収まらない場合のみ使う。
    pub overflow_sector: u64,
    /// インラインのエクステント配列。
    pub extents: [Extent; MAX_INLINE_EXTENTS],
}

// 【2026-07-26】`FileMetadata` は 1 セクタ(508B)へ丸ごと書き込む前提の構造体。
// フィールドを足して 508 バイトを超えると、書き込み時に末尾が切り捨てられて
// データセクタ番号が失われ、**ファイルが静かに壊れる**（実行時まで気付けない）。
// 間接ブロック用の `indirect_sector` 追加のような変更で容易に起こりうるため、
// コンパイル時に検査する。
const _: () = assert!(
    core::mem::size_of::<FileMetadata>() <= DATA_SIZE_PER_SECTOR,
    "FileMetadata must fit within a single sector"
);

impl FileMetadata {
    pub fn new(name: &str, labels: &str, size: u64) -> Self {
        let mut fm = Self {
            filename: [0; 128],
            label_data: [0; 64],
            size,
            extent_count: 0,
            overflow_sector: 0,
            extents: [Extent::default(); MAX_INLINE_EXTENTS],
        };

        // UTF-8 セーフな切り捨て処理 (最大 127 バイト)
        let mut name_valid_len = 0;
        for (i, c) in name.char_indices() {
            if i + c.len_utf8() > 127 {
                break;
            }
            name_valid_len = i + c.len_utf8();
        }
        let name_bytes = name.as_bytes();
        fm.filename[..name_valid_len].copy_from_slice(&name_bytes[..name_valid_len]);

        let mut label_valid_len = 0;
        for (i, c) in labels.char_indices() {
            if i + c.len_utf8() > 63 {
                break;
            }
            label_valid_len = i + c.len_utf8();
        }
        let label_bytes = labels.as_bytes();
        fm.label_data[..label_valid_len].copy_from_slice(&label_bytes[..label_valid_len]);

        fm
    }

    pub fn get_filename(&self) -> &str {
        let len = self.filename.iter().position(|&x| x == 0).unwrap_or(128);
        unsafe { core::str::from_utf8_unchecked(&self.filename[..len]) }
    }

    pub fn get_labels(&self) -> &str {
        let len = self.label_data.iter().position(|&x| x == 0).unwrap_or(64);
        unsafe { core::str::from_utf8_unchecked(&self.label_data[..len]) }
    }
}

pub struct SylFS {
    pub device: MirroredBlockDevice<block::BackendDevice>,
    pub superblock: Superblock,
    /// 次に空きを探し始めるビットマップセクタ（`allocate_sector` 用）。
    ///
    /// 【2026-08-05】以前は毎回**先頭から**走査していた。
    /// 5.3MB のフォントを保存すると 1 万回以上 `allocate_sector` を呼ぶが、
    /// 前の方はもう埋まっているので、埋まるほど走査が長くなる。**O(n²)**。
    ///
    /// 実測: `cache書=3636tick/14回`（1 回 260 tick＝2.6 秒）。
    ///
    /// 前回見つけた位置から再開すれば、連続確保が O(1) 近くになる。
    /// 見つからなければ 0 へ戻して**一巡**するので取りこぼしは無い。
    next_bitmap_hint: u32,
}

impl SylFS {
    /// フォーマット済みのデバイスから `SylFS` を組み立てる。
    ///
    /// 内部状態（`next_bitmap_hint`）を持つようになったので、
    /// 構造体リテラルではなくこれを使う。
    /// 試験からも同じ経路で作れる（`tests/src/test_fs_error_propagation.rs`）。
    pub fn from_parts(
        device: MirroredBlockDevice<block::BackendDevice>,
        superblock: Superblock,
    ) -> Self {
        Self {
            device,
            superblock,
            next_bitmap_hint: 0,
        }
    }
}

static mut FS_INSTANCE: *mut SylFS = null_mut();

// build.rs が自動生成したプリインストールアプリのアセット（AppAsset構造体とAPP_ASSETS配列）を読み込む
include!(concat!(env!("OUT_DIR"), "/app_assets.rs"));

/// デバイスを SylFS としてフォーマットし、書き込んだスーパーブロックを返します。
///
/// 【2026-07-28】従来はビットマップ領域とスーパーブロックの書き込みを
/// `let _ = device.write_sector(...)` で捨てたうえ、無条件に
/// 「Format completed successfully!」と出力していた。スーパーブロックが
/// 書けていなければ次回起動でも「未フォーマット」と判定されるため、
/// **毎回フォーマットし直して保存内容が全部消えるのに、ログ上は毎回成功**
/// という最悪の隠蔽になっていた。1 セクタでも書けなければエラーを返す。
pub fn format_device(
    device: &mut MirroredBlockDevice<block::BackendDevice>,
) -> Result<Superblock, &'static str> {
    let total = device.total_usable_sectors() as u64;
    let bitmap_sectors = bitmap_sectors_for(total);

    let superblock = Superblock {
        magic: *SYLFS_MAGIC,
        version: 1,
        root_sector: 0, // 初期ツリーは空
        bitmap_start: BITMAP_START_SECTOR,
        bitmap_sectors: bitmap_sectors as u32,
    };

    crate::info!(
        "[FS] Formatting: total_sectors={} bitmap_sectors={} (capacity {} MiB)",
        total,
        bitmap_sectors,
        total * DATA_SIZE_PER_SECTOR as u64 / (1024 * 1024)
    );

    // 空きセクタビットマップの初期化。
    // 先頭のスーパーブロック(セクタ0)とビットマップ領域自身を使用済みにする。
    let reserved = 1 + bitmap_sectors; // sector 0 + bitmap
    let mut first = [0u8; DATA_SIZE_PER_SECTOR];
    for s in 0..reserved.min(BITS_PER_BITMAP_SECTOR) {
        let byte = (s / 8) as usize;
        let bit = (s % 8) as u8;
        first[byte] |= 1 << bit;
    }

    for i in 0..bitmap_sectors {
        let sec = BITMAP_START_SECTOR as u64 + i;
        let data_to_write = if i == 0 {
            &first[..]
        } else {
            &[0u8; DATA_SIZE_PER_SECTOR][..]
        };
        if let Err(e) = device.write_sector(sec as usize, data_to_write) {
            crate::error!("[FS] Format failed: bitmap sector {} not written: {}", sec, e);
            return Err(e);
        }
    }

    // Superblockをコミット
    let mut sb_buf = [0u8; DATA_SIZE_PER_SECTOR];
    unsafe {
        core::ptr::copy_nonoverlapping(
            &superblock as *const Superblock as *const u8,
            sb_buf.as_mut_ptr(),
            core::mem::size_of::<Superblock>(),
        );
    }
    if let Err(e) = device.write_sector(SUPERBLOCK_SECTOR, &sb_buf) {
        crate::error!("[FS] Format failed: superblock not written: {}", e);
        return Err(e);
    }

    crate::info!("[FS] Format completed successfully!");
    Ok(superblock)
}

/// ファイルシステムを microSD または RAMDisk 上にマウント（初期化）します。
/// 未フォーマットの場合は自動的にフォーマットを実行します。
///
/// 失敗しても起動を止めないため `FS_INSTANCE` は必ず設定するが、
/// **フォーマット失敗・プリインストールアプリの書き込み失敗は握り潰さず
/// 呼び出し側へ返す**（従来はどちらも `let _ =` で捨てていた）。
pub fn mount() -> Result<(), &'static str> {
    crate::info!("[FS] Mounting SylFS (COW Label-based File System)...");

    // まずオンボードの microSD カード (SDHOST 制御) の初期化を試みます
    let backend = match block::SDCard::new() {
        Ok(sd_card) => {
            crate::info!("[FS] microSD card backend successfully initialized.");
            block::BackendDevice::SD(sd_card)
        }
        Err(e) => {
            crate::warn!("[FS] Failed to initialize microSD card: {}. Falling back to RAMDisk...", e);
            // フォールバック: 8MBのRAMディスクを確保 (512B * 16,384セクタ)
            // 【2026-07-31】RAMDisk のサイズ根拠。
            //
            // 前提（いずれも実測・コード確認済み）:
            //  - `RAMDisk::new` は `vec![0u8; size]` で**起動時に全量を即確保**する。
            //    遅延確保ではないので、指定した分だけヒープを最初から消費する。
            //  - カーネルヒープは 512MB（`main.rs` の `heap_size`）。
            //  - `MirroredBlockDevice` は自己修復のため **容量を半分**にする
            //    （`block.rs` の `half_sectors = total_sectors() / 2`）。
            //    → 指定 N バイトの実効容量は N/2。
            //  - Raspberry Pi 3B+ の搭載 RAM は 1GB。
            //
            // 必要量の見積り（www.sugi-lab.net 1 ページ分の実測値）:
            //    Noto Sans JP  5.3MB × 4 ウェイト = 21.2MB
            //    背景写真                          =  3.7MB
            //    Font Awesome woff2 0.1MB × 4      =  0.4MB
            //    CSS / JS / HTML                   =  0.2MB
            //                                  計 ≒ 26MB / サイト
            //
            // 数サイト分を保持したいので実効 64MB を確保する。
            // ミラーで半分になるため指定値は 128MB。
            // ヒープ 512MB の 25% で、1GB 搭載機なら妥当な範囲。
            //
            // なお RAMDisk は「SD が使えないときのフォールバック」だけでなく、
            // **一時ファイル（/cache, /tmp）の正規の置き場**でもある。
            // キャッシュを SD へ書くとフラッシュの書き換え回数を消費して
            // 寿命を縮めるため、一時ファイルは常に RAM 上に置く
            // （`fs/storage_policy.rs` の方針、単体試験 6 件で固定）。
            // 【2026-08-25】ヒープ外の物理空き RAM をそのまま記憶装置に使う。
            // 実測では 0x2331_19E0 〜 0x3800_0000（332MB）。
            // 開始はヒープ末尾、終端は `mmu::DEVICE_REGION_START`。
            // 専用RAMDiskとして直接マッピング。ヒープを1バイトも消費せず、広大な空きRAMを100%有効活用する。
            extern "C" {
                static __cpu_stacks_end: u8;
            }
            let heap_start = core::ptr::addr_of!(__cpu_stacks_end) as usize;
            // `main.rs` と同じ値でなければヒープに重なる。定義は 1 箇所。
            let heap_size = crate::kernel::allocator::KERNEL_HEAP_SIZE;
            let ramdisk_start = heap_start + heap_size;
            // 境界の定義は `mmu.rs`（マップを決めている側）が権威。
            // ここで別の値を書くと、RAMDisk がフレームバッファを踏む。
            let gpu_boundary = crate::kernel::mmu::DEVICE_REGION_START;
            let ramdisk_size = if gpu_boundary > ramdisk_start {
                gpu_boundary - ramdisk_start
            } else {
                64 * 1024 * 1024
            };

            let ram_disk = unsafe { block::RAMDisk::from_raw_memory(ramdisk_start, ramdisk_size) };
            // 【2026-08-25】`info!` は既定のログ水準（Warn）では**出ない**。
            // ここは「どの物理範囲を記憶装置に使ったか」という
            // 起動時 1 回だけの重要な事実で、範囲を誤れば GPU 領域を踏んで
            // 画面が壊れる。確認できるよう必ず記録する（L-1）。
            crate::warn!(
                "[FS] Dedicated RAMDisk allocated from 0x{:08X} to 0x{:08X} ({} MB)",
                ramdisk_start,
                ramdisk_start + ramdisk_size,
                ramdisk_size / (1024 * 1024)
            );
            block::BackendDevice::RAM(ram_disk)
        }
    };

    let mut device = MirroredBlockDevice::new(backend);

    let mut superblock = Superblock {
        magic: [0; 8],
        version: 0,
        root_sector: 0,
        bitmap_start: BITMAP_START_SECTOR,
        bitmap_sectors: 4, // 実際の値はマウント時に読み込むか、フォーマット時に算出する
    };

    let mut is_formatted = false;
    let mut buf = [0u8; DATA_SIZE_PER_SECTOR];

    // Superblock (セクタ0) の読み込み試行。未フォーマット時の警告出力をサイレント化する。
    crate::kernel::uart::set_silent(true);
    let read_res = device.read_sector(SUPERBLOCK_SECTOR, &mut buf);
    crate::kernel::uart::set_silent(false);

    if read_res.is_ok() {
        unsafe {
            core::ptr::copy_nonoverlapping(
                buf.as_ptr(),
                &mut superblock as *mut Superblock as *mut u8,
                core::mem::size_of::<Superblock>(),
            );
        }
        if &superblock.magic == SYLFS_MAGIC {
            is_formatted = true;
            let root_sec = superblock.root_sector;
            crate::info!(
                "[FS] SylFS successfully mounted! Root B-Tree root at Sector {}",
                root_sec
            );
        }
    }

    // 最初に検出した失敗を保持する（起動は続けるが、必ず呼び出し側へ返す）。
    let mut status: Result<(), &'static str> = Ok(());

    if !is_formatted {
        crate::info!("[FS] SylFS not detected. Formatting disk...");
        match format_device(&mut device) {
            Ok(sb) => superblock = sb,
            Err(e) => {
                // フォーマットできていないので、この後のファイル操作はほぼ
                // すべて失敗する。黙って「成功」にせず記録して先へ進む。
                crate::error!("[FS] Format failed: {}", e);
                status = Err(e);
            }
        }
    }

    let fs = Box::new(SylFS::from_parts(device, superblock));
    unsafe {
        FS_INSTANCE = Box::into_raw(fs);
    }

    // デフォルトアプリは毎起動時に最新の状態で上書き（パーミッションの更新などのため）
    let fs_ref = get_fs();

    let mut asset_failures = 0usize;
    for asset in APP_ASSETS.iter() {
        if let Err(e) = fs_ref.save_file(asset.path, asset.data, "sys") {
            // 書けなかったアプリは起動できない。どのアプリがなぜ入らなかったかを
            // 残さないと「アプリが無い」としか分からなくなる。
            crate::error!("[FS] Failed to install default app '{}': {}", asset.path, e);
            asset_failures += 1;
        }
    }

    if asset_failures > 0 {
        crate::error!(
            "[FS] {} of {} pre-installed apps could not be written.",
            asset_failures,
            APP_ASSETS.len()
        );
        if status.is_ok() {
            status = Err("failed to install pre-installed apps");
        }
    } else {
        crate::info!("[FS] Pre-installed default apps updated.");
    }

    status
}

/// ファイルを読み込んでバイト列を返すヘルパー (WiFiファームウェアロード等に使用)
pub fn read_file(path: &str) -> Option<alloc::vec::Vec<u8>> {
    let fs = get_fs();
    let (_meta, data) = fs.read_file(path)?;
    Some(data)
}

/// ファイルシステムがマウント済みかどうか。
pub fn is_mounted() -> bool {
    unsafe { !FS_INSTANCE.is_null() }
}

/// グローバルなファイルシステムインスタンスを取得
///
/// # SMP 安全性についての注記（2026-07-14 調査）
/// この関数は `static mut` の生ポインタから `&'static mut` を無条件に発行
/// するため、型システム上はマルチコアからの並行呼び出しに対して無防備
/// （排他ロックを一切持たない）。`spec/TODO.md`「デバッグ・検証候補」節の
/// P1 疑いとして監査した結果、`get_fs()`（および `read_file`/`write_file`
/// 等）を実際に呼ぶコードは、`kernel/fs/mod.rs` 以外の21ファイル
/// （JS/Aura ビルトイン・各アプリ・`web_engine`・`cloud.rs` 等）を含め
/// 全て `Core 0` に `spawn_on_core` で固定された単一プロセス
/// `gui_shell_process`（`main.rs`）の実行文脈内でのみ呼ばれており、
/// `Core 1`（`usb_poll_thread`。USB/HID ポーリングのみ）・`Core 2`
/// （`net_service_thread`。NTP 同期のみ）はいずれもファイルシステムへ
/// 一切アクセスしないことを確認済み。したがって**現状のアーキテクチャでは
/// 実際の並行アクセスは発生せず実害は無い**。ただし、この安全性は
/// コンパイラ/型システムが保証するものではなく「今のところ誰も他コアから
/// 呼んでいない」という運用上の不変条件に過ぎないため、**今後 FS へ
/// アクセスするコードを Core 1〜3 側（`spawn_on_core` の新規呼び出し等）に
/// 追加する場合は、先に排他機構（`spin::Mutex` 等）の導入を検討すること**。
/// ファイルシステム全体を直列化するロック。
///
/// 【2026-08-05】上の注記が予告していた事態が実際に起きた。
/// リソース取得を 4 並列にしたことで、複数のワーカースレッドが
/// 同時に `web_engine/cache.rs` 経由で FS を触るようになり、
/// **空きセクタビットマップが壊れた**。実測の症状:
///
/// ```text
/// [SylFS] Failed to read bitmap sector 10
/// read '...': data sector 19997 unreadable: both primary and mirror corrupted
/// read_file('...') failed: extent list unreadable
/// [CACHE] 保存は成功したのに読み返せない key=... bytes=5327688
/// ```
///
/// 結果として 5.3MB のフォントも 3.7MB の画像もキャッシュに残らず、
/// **毎回 14MB を取り直していた**（速度にも直結する）。
///
/// `get_fs()` は `&'static mut` を返すので、ロックを関数の中へ隠せない
/// （借用が呼び出し側へ渡るため）。呼び出し側が操作の間だけ保持する。
///
/// **今後 FS を触るコードを増やすときは必ずこのロックを取ること。**
///
/// 【2026-08-25】以前ここに「現状の取得者は `cache.rs` だけ」と書いてあり、
/// その記述が古いまま放置された結果、番人なしで FS を触る箇所が
/// 4 つ増えていた（`layout/values.rs` の画像サイズ解決、
/// `apps/browser/mod.rs` のローカルパス読み込み 2 箇所、
/// `js/builtins/web_forms.rs` の localStorage 書き出し）。
/// とくに最後のひとつは**書き込み**で、ワーカーの書き込みと重なると
/// 空きセクタビットマップが二重確保され、無関係なファイルが壊れる。
///
/// **判定の基準は「ブラウザのワーカースレッドと同時に走りうるか」**。
/// ブラウザが動いている間、フォント・画像・ローダの各ワーカーは
/// 常時 FS へ書いている。UI スレッドだから安全、とは言えない。
///
/// 取得者を個別に数え上げる書き方はまた古くなるので、ここには書かない。
/// 探すときは `FS_LOCK` を grep し、`get_fs()` の呼び出しと突き合わせること。
/// 【2026-08-25 バグ修正】ここは素の `spin::Mutex` だった。
///
/// AtmOS は `panic = "abort"` で巻き戻しが無いので、ロックを持ったまま
/// パニックすると**そのロックは永久に解放されない**。だから
/// `#[panic_handler]` はヒープ・ネットワーク・USB のロックを
/// 死んだコアから強制的に取り上げている。
///
/// FS_LOCK は後から足したためその手当てが漏れていた。
/// 画像ワーカーは `os_lib/webp`（panic 禁止ポリシーの**対象外**と
/// 明記されたベンダリング済みデコーダ）を回しながら FS_LOCK を取る。
/// 壊れた WebP 一枚で番人が居座り、以後 OS 全体の FS 操作が
/// 永久に止まる。ネットワークや USB と同じ扱いにする。
pub static FS_LOCK: crate::kernel::reclock::RecoverableMutex<()> =
    crate::kernel::reclock::RecoverableMutex::new(());

/// パニックしたコアが保持していた FS ロックを取り上げる。
/// 他コアが正当に持っているロックには触れない。
pub fn force_release_locks(cid: i16) {
    unsafe {
        FS_LOCK.force_release_if_core(cid);
    }
}

pub fn get_fs() -> &'static mut SylFS {
    unsafe {
        assert!(!FS_INSTANCE.is_null(), "SylFS not mounted!");
        &mut *FS_INSTANCE
    }
}

impl SylFS {
    /// 空きセクタをビットマップから探索・確保します (COWトランザクション用)
    pub fn allocate_sector(&mut self) -> u32 {
        let mut buf = [0u8; DATA_SIZE_PER_SECTOR];

        // ビットマップ領域を順次走査（長さはフォーマット時にデバイス容量から
        // 算出してスーパーブロックへ記録済み。固定 4 セクタではない）。
        //
        // 【2026-08-05】開始位置を前回の続きにする（`next_bitmap_hint`）。
        // 毎回先頭からだと、埋まるほど走査が伸びて O(n²) になっていた。
        // 見つからなければそのまま一巡するので取りこぼしは無い。
        let total = self.superblock.bitmap_sectors;
        for step in 0..total {
            let i = (self.next_bitmap_hint + step) % total.max(1);
            let sec = self.superblock.bitmap_start + i;
            if self.device.read_sector(sec as usize, &mut buf).is_err() {
                println!("[SylFS] Failed to read bitmap sector {}", sec);
                continue;
            }

            for byte_idx in 0..DATA_SIZE_PER_SECTOR {
                let byte = buf[byte_idx];
                if byte != 0xFF {
                    // 空きビット(0)を発見
                    for bit in 0..8 {
                        if (byte & (1 << bit)) == 0 {
                            // 使用済みに設定 (1に書き換え)
                            buf[byte_idx] |= 1 << bit;

                            // ビットマップセクタを更新 (COWトランザクション)
                            // 【2026-07-27】ここの失敗を握り潰すと、確保したつもりの
                            // セクタがビットマップ上は空きのままになり、**別のファイルへ
                            // 二重割り当てされてデータが破壊される**。確保失敗として
                            // 0 を返し、呼び出し側にエラーを伝える。
                            if let Err(e) = self.device.write_sector(sec as usize, &buf) {
                                crate::error!(
                                    "[SylFS] allocate_sector: bitmap write failed on sector {}: {}",
                                    sec,
                                    e
                                );
                                return 0;
                            }

                            // 次の確保はこのセクタから探し始める。
                            self.next_bitmap_hint = i;
                            let allocated_sector = (i * DATA_SIZE_PER_SECTOR as u32 * 8)
                                + (byte_idx as u32 * 8)
                                + bit as u32;
                            // 【2026-08-05】ビットマップは**デバイスより多くのビットを持つ**。
                            //
                            // ビットマップ長は `total.div_ceil(4064)` で切り上げるので、
                            // 最後のセクタには実在しないセクタに対応する余剰ビットが残る
                            // （実効 64MB = 131,072 セクタなら 33 × 4,064 = 134,112 ビットで
                            //   3,040 ビットが余る）。
                            //
                            // 余剰ビットは空き(0)のままなので、ディスクが埋まってくると
                            // ここが**存在しないセクタ番号**を返し、以後の読み書きが
                            // `read_sector: sector out of range` で失敗していた。
                            // 「満杯」ではなく意味不明なエラーとして表面化するため、
                            // 実測では 5.3MB のフォントが「保存に失敗」と出るだけで
                            // 原因がまったく分からない状態だった。
                            //
                            // 範囲外なら確保せず、満杯として扱う。
                            if allocated_sector as usize >= self.device.total_usable_sectors() {
                                // 立てたビットを戻す（このセクタは使えない）。
                                buf[byte_idx] &= !(1 << bit);
                                // 【2026-08-05】戻し書きの失敗を握り潰していた。
                                // 失敗すると**ビットが立ったまま**になり、
                                // 実在しないセクタが恒久的に「使用中」として
                                // 残る（セクタリーク）。必ず記録する（L-1）。
                                if let Err(e) = self.device.write_sector(sec as usize, &buf) {
                                    crate::error!(
                                        "[SylFS] allocate_sector: 余剰ビットの戻し書きに失敗 sector={} err={}（ビットが漏れる）",
                                        sec,
                                        e
                                    );
                                }
                                crate::warn!(
                                    "[SylFS] allocate_sector: ビットマップの余剰ビットに到達 (sector={} usable={})。満杯として扱う",
                                    allocated_sector,
                                    self.device.total_usable_sectors()
                                );
                                return 0;
                            }
                            return allocated_sector;
                        }
                    }
                }
            }
        }
        println!("[SylFS] allocate_sector failed (Disk Full)");
        0 // ディスク満杯
    }

    /// 指定したセクタをビットマップで解放します
    pub fn deallocate_sector(&mut self, sector: u32) {
        let i = sector / (DATA_SIZE_PER_SECTOR as u32 * 8);
        let rem = sector % (DATA_SIZE_PER_SECTOR as u32 * 8);
        let byte_idx = (rem / 8) as usize;
        let bit = rem % 8;

        let sec = self.superblock.bitmap_start + i;
        let mut buf = [0u8; DATA_SIZE_PER_SECTOR];
        if self.device.read_sector(sec as usize, &mut buf).is_ok() {
            buf[byte_idx] &= !(1 << bit); // ビットを0 (空き) に設定
            // 【2026-07-27】ビットマップ更新の失敗を握り潰すと、解放したはずの
            // セクタが使用中のまま残り続け（セクタリーク）、やがて Disk Full に
            // なる。原因を追えるようログを出す。
            if let Err(e) = self.device.write_sector(sec as usize, &buf) {
                crate::error!(
                    "[SylFS] deallocate_sector({}): bitmap write failed: {} (sector leaked)",
                    sector,
                    e
                );
            }
        } else {
            crate::error!(
                "[SylFS] deallocate_sector({}): bitmap read failed (sector leaked)",
                sector
            );
        }
    }

    /// ファイルを新しく保存（または上書き）します (COWによる完全保護)
    pub fn save_file(
        &mut self,
        filename: &str,
        content: &[u8],
        labels: &str,
    ) -> Result<(), &'static str> {
        crate::debug!("[FS] Saving file '{}' with labels [{}]...", filename, labels);

        // 1. ファイルデータ用の空きセクタを確保し、データを書き込む。
        //    確保したセクタが連続していれば 1 本のエクステントへまとめる
        //    （NTFS の run / exFAT と同じ考え方）。これにより
        //    「セクタ番号を 1 個ずつ並べる」方式にあったサイズ上限が無くなる。
        let needed_sectors = content.len().div_ceil(DATA_SIZE_PER_SECTOR);

        let mut extents: Vec<Extent> = Vec::new();
        for i in 0..needed_sectors {
            let sec = self.allocate_sector() as u64;
            if sec == 0 {
                return Err("save_file: no free data sector");
            }

            match extents.last_mut() {
                // 直前のエクステントの続きなら伸ばすだけ
                Some(last) if last.start + last.count == sec => last.count += 1,
                _ => extents.push(Extent {
                    start: sec,
                    count: 1,
                }),
            }

            let offset = i * DATA_SIZE_PER_SECTOR;
            let end = (offset + DATA_SIZE_PER_SECTOR).min(content.len());
            // 【2026-07-27】データ書き込みの失敗を `let _ =` で握り潰していたため、
            // **1 セクタも書けていなくても save_file が成功を返す**（＝ファイルが
            // 静かに壊れる）状態だった。失敗はログを出したうえでエラーとして返す。
            if let Err(e) = self
                .device
                .write_sector(sec as usize, &content[offset..end])
            {
                crate::error!(
                    "[SylFS] save_file('{}'): data sector {} write failed: {}",
                    filename,
                    sec,
                    e
                );
                return Err("save_file: data sector write failed");
            }
        }

        // インラインに収まらない分は溢れセクタのチェーンへ書き出す。
        let inline_count = extents.len().min(MAX_INLINE_EXTENTS);
        let mut inline_extents = [Extent::default(); MAX_INLINE_EXTENTS];
        inline_extents[..inline_count].copy_from_slice(&extents[..inline_count]);
        let overflow_sector = self.write_overflow_extents(&extents[inline_count..])?;

        // 2. メタデータオブジェクトを作成し、空きセクタに書き込み
        let meta_sector = self.allocate_sector();
        if meta_sector == 0 {
            return Err("save_file: no free metadata sector");
        }
        let mut meta = FileMetadata::new(filename, labels, content.len() as u64);
        meta.extents = inline_extents;
        meta.extent_count = extents.len() as u32;
        meta.overflow_sector = overflow_sector;

        let mut meta_buf = [0u8; DATA_SIZE_PER_SECTOR];
        unsafe {
            core::ptr::copy_nonoverlapping(
                &meta as *const FileMetadata as *const u8,
                meta_buf.as_mut_ptr(),
                core::mem::size_of::<FileMetadata>(),
            );
        }
        self.device.write_sector(meta_sector as usize, &meta_buf)?;

        // 3. B-Tree インデックスへの登録
        let mut btree = CowBTree::new(self.superblock.root_sector);

        // ラムダ式の借用問題を避けるため、セクタ割り当て用の関数をローカルクロージャで構成
        let self_ptr = self as *mut Self;
        let mut alloc_fn = || unsafe { (*self_ptr).allocate_sector() };

        // 3-1. ファイル名インデックスへの登録 (128-bitハッシュ)
        let hash_key = fnv1a_128(filename.as_bytes());
        let new_root = btree.insert(&mut self.device, &hash_key, meta_sector, &mut alloc_fn)?;
        self.superblock.root_sector = new_root;

        // 4. Superblock を更新して、一括コミット (アトミック・整合状態確定)
        let mut sb_buf = [0u8; DATA_SIZE_PER_SECTOR];
        unsafe {
            core::ptr::copy_nonoverlapping(
                &self.superblock as *const Superblock as *const u8,
                sb_buf.as_mut_ptr(),
                core::mem::size_of::<Superblock>(),
            );
        }
        self.device.write_sector(SUPERBLOCK_SECTOR, &sb_buf)?;

        crate::debug!(
            "  File '{}' successfully saved! Metadata stored at Sector {}",
            filename,
            meta_sector
        );
        Ok(())
    }

    /// 指定した名前のファイルの内容をロードして返します
    /// (チェックサム自動検証 ＆ 自己修復付き、Overlay ROM フォールバック対応)。
    ///
    /// # 【2026-07-28】互換用のラッパーであること
    /// 戻り値が `Option` のため、**「本当に存在しない」と「存在するが読めない」を
    /// 区別できない**。とくに設定ファイルの読み出しでこれを「存在しない」と
    /// 解釈すると既定値で上書きしてしまい、**読めなかっただけのファイルを
    /// 破棄する**ことになる（実際に `config.rs` がその経路を持っていた）。
    /// 新規のコードは区別できる [`SylFS::read_file_checked`] を使うこと。
    /// ここでは少なくとも失敗を無言にしないため、エラーをログへ出す。
    pub fn read_file(&mut self, filename: &str) -> Option<(FileMetadata, Vec<u8>)> {
        match self.read_file_checked(filename) {
            Ok(v) => v,
            Err(e) => {
                crate::error!("[SylFS] read_file('{}') failed: {}", filename, e);
                None
            }
        }
    }

    /// ファイルを読み出す。**「存在しない」と「読めない」を区別する**版。
    ///
    /// - `Ok(None)` … ファイルが存在しない（正常な結果）
    /// - `Ok(Some(..))` … 正常に読めた
    /// - `Err(e)` … 存在するはずなのに読めない（デバイス異常・両系破損・
    ///   ハッシュ衝突・実体セクタの欠落）。**呼び出し側はこれを「無い」と
    ///   扱ってはならない**（上書きするとデータを失う）。
    pub fn read_file_checked(
        &mut self,
        filename: &str,
    ) -> Result<Option<(FileMetadata, Vec<u8>)>, &'static str> {
        let btree = CowBTree::new(self.superblock.root_sector);

        // 1. B-Treeからファイル名のハッシュでメタデータセクタを検索
        let hash_key = fnv1a_128(filename.as_bytes());
        let meta_sector = match btree.search(&mut self.device, &hash_key) {
            Some(sec) => sec,
            None => {
                // Overlay/ROM フォールバック: SD カード上にファイルが存在しない、または削除された場合は
                // コンパイル時に埋め込まれた APP_ASSETS (ROM) から透過的にデータを返します。
                for asset in APP_ASSETS.iter() {
                    if asset.path == filename {
                        let dummy_meta = FileMetadata::new(filename, "rom", asset.data.len() as u64);
                        return Ok(Some((dummy_meta, asset.data.to_vec())));
                    }
                }
                // ここだけが「本当に存在しない」正常な結果。
                return Ok(None);
            }
        };

        // 2. メタデータブロックを読み込み
        let mut buf = [0u8; DATA_SIZE_PER_SECTOR];
        if let Err(e) = self.device.read_sector(meta_sector as usize, &mut buf) {
            crate::error!(
                "[SylFS] read '{}': metadata sector {} unreadable: {}",
                filename,
                meta_sector,
                e
            );
            return Err("metadata sector unreadable");
        }
        let meta = unsafe { *(buf.as_ptr() as *const FileMetadata) };
        if meta.get_filename() != filename {
            // Hash collision (very rare)。「無い」ではなく異常として返す。
            crate::error!(
                "[SylFS] read '{}': hash collision with '{}'",
                filename,
                meta.get_filename()
            );
            return Err("filename hash collision");
        }

        // 3. データセクタから実体を結合・読み出し
        let mut content = Vec::new();
        let mut total_read = 0;
        let mut i = 0;

        // エクステントを辿って全データセクタ番号を論理順に得る。
        let extents = self
            .collect_extents(&meta)
            .ok_or("extent list unreadable")?;
        let all_secs = Self::extents_to_sectors(&extents);

        while total_read < meta.size && i < all_secs.len() {
            let sec = all_secs[i];
            let mut data_buf = [0u8; DATA_SIZE_PER_SECTOR];
            if let Err(e) = self.device.read_sector(sec as usize, &mut data_buf) {
                crate::error!(
                    "[SylFS] read '{}': data sector {} unreadable: {}",
                    filename,
                    sec,
                    e
                );
                return Err("data sector unreadable");
            }

            let remain = (meta.size - total_read) as usize;
            let chunk_size = remain.min(DATA_SIZE_PER_SECTOR);
            content.extend_from_slice(&data_buf[..chunk_size]);

            total_read += chunk_size as u64;
            i += 1;
        }

        // 実体が足りないまま終わった場合も「読めた」と言ってはいけない
        // （途中までのデータを正常な内容として返すと、静かにファイルが壊れる）。
        // `FileMetadata` は packed なのでフィールドへの参照を作らずコピーする。
        let expected_size = meta.size;
        if total_read < expected_size {
            crate::error!(
                "[SylFS] read '{}': truncated ({} of {} bytes)",
                filename,
                total_read,
                expected_size
            );
            return Err("file data is truncated");
        }

        Ok(Some((meta, content)))
    }

    /// インラインに収まらないエクステント群を、セクタのチェーンへ書き出す。
    /// 各セクタは先頭 8 バイトが「次のセクタ番号(0 で終端)」、以降が
    /// `Extent` の並び。戻り値はチェーン先頭のセクタ番号（不要なら 0）。
    fn write_overflow_extents(&mut self, rest: &[Extent]) -> Result<u64, &'static str> {
        if rest.is_empty() {
            return Ok(0);
        }
        // 後ろのチャンクから作って「次」を繋いでいく。
        let mut next: u64 = 0;
        let mut head: u64 = 0;
        for chunk in rest.chunks(EXTENTS_PER_OVERFLOW_SECTOR).rev() {
            let sec = self.allocate_sector() as u64;
            if sec == 0 {
                return Err("save_file: no free overflow sector");
            }
            let mut buf = [0u8; DATA_SIZE_PER_SECTOR];
            buf[..8].copy_from_slice(&next.to_le_bytes());
            for (i, e) in chunk.iter().enumerate() {
                let off = 8 + i * 16;
                buf[off..off + 8].copy_from_slice(&e.start.to_le_bytes());
                buf[off + 8..off + 16].copy_from_slice(&e.count.to_le_bytes());
            }
            // 【2026-07-27】溢れエクステント表の書き込み失敗を握り潰すと、
            // メタデータは「続きがある」と記録しているのに実体が無い状態になり、
            // ファイルが途中までしか読めなくなる。エラーとして返す。
            if let Err(e) = self.device.write_sector(sec as usize, &buf) {
                crate::error!(
                    "[SylFS] write_overflow_extents: sector {} write failed: {}",
                    sec,
                    e
                );
                return Err("save_file: overflow extent write failed");
            }
            next = sec;
            head = sec;
        }
        Ok(head)
    }

    /// メタデータから全エクステントを論理順に集める（インライン＋溢れチェーン）。
    fn collect_extents(&mut self, meta: &FileMetadata) -> Option<Vec<Extent>> {
        let total = meta.extent_count as usize;
        let mut out: Vec<Extent> = Vec::with_capacity(total);

        let inline_n = total.min(MAX_INLINE_EXTENTS);
        for e in meta.extents.iter().take(inline_n) {
            out.push(*e);
        }

        let mut next = meta.overflow_sector;
        while next != 0 && out.len() < total {
            let mut buf = [0u8; DATA_SIZE_PER_SECTOR];
            if self.device.read_sector(next as usize, &mut buf).is_err() {
                return None;
            }
            let following = u64::from_le_bytes([
                buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6], buf[7],
            ]);
            for i in 0..EXTENTS_PER_OVERFLOW_SECTOR {
                if out.len() >= total {
                    break;
                }
                let off = 8 + i * 16;
                let start = u64::from_le_bytes([
                    buf[off], buf[off + 1], buf[off + 2], buf[off + 3],
                    buf[off + 4], buf[off + 5], buf[off + 6], buf[off + 7],
                ]);
                let count = u64::from_le_bytes([
                    buf[off + 8], buf[off + 9], buf[off + 10], buf[off + 11],
                    buf[off + 12], buf[off + 13], buf[off + 14], buf[off + 15],
                ]);
                if count == 0 {
                    continue;
                }
                out.push(Extent { start, count });
            }
            next = following;
        }
        Some(out)
    }

    /// エクステント列を、論理順のセクタ番号列へ展開する。
    fn extents_to_sectors(extents: &[Extent]) -> Vec<u64> {
        let mut secs = Vec::new();
        for e in extents {
            for k in 0..e.count {
                secs.push(e.start + k);
            }
        }
        secs
    }

    /// 特定のラベルが割り当てられているファイルをすべて列挙して検索します (メタデータ走査)
    pub fn find_by_label(&mut self, label: &str) -> Vec<FileMetadata> {
        let mut results = Vec::new();
        let all_files = self.list_files();
        for meta in all_files {
            if meta.get_labels().split(',').any(|l| l.trim() == label) {
                results.push(meta);
            }
        }
        results
    }

    /// すべての通常ファイルを列挙します
    pub fn list_files(&mut self) -> Vec<FileMetadata> {
        let btree = CowBTree::new(self.superblock.root_sector);
        let mut entries = Vec::new();
        let mut results = Vec::new();
        let mut seen_meta_sectors = Vec::new();

        btree.collect_leaf_entries(&mut self.device, &mut entries);

        for (_, meta_sector) in entries {
            if seen_meta_sectors.contains(&meta_sector) {
                continue;
            }
            seen_meta_sectors.push(meta_sector);

            let mut buf = [0u8; DATA_SIZE_PER_SECTOR];
            if self
                .device
                .read_sector(meta_sector as usize, &mut buf)
                .is_ok()
            {
                let meta = unsafe { *(buf.as_ptr() as *const FileMetadata) };
                // 削除済みファイル (ファイル名の先頭がNULバイト) は除外
                if meta.filename[0] != 0 {
                    results.push(meta);
                }
            }
        }

        results
    }

    /// 指定した名前のファイルを削除します (メタデータとデータセクタの安全な解放)
    pub fn delete_file(&mut self, filename: &str) -> Result<(), &'static str> {
        let btree = CowBTree::new(self.superblock.root_sector);
        let hash_key = fnv1a_128(filename.as_bytes());

        if let Some(meta_sector) = btree.search(&mut self.device, &hash_key) {
            let mut buf = [0u8; DATA_SIZE_PER_SECTOR];
            if self
                .device
                .read_sector(meta_sector as usize, &mut buf)
                .is_ok()
            {
                let mut meta = unsafe { *(buf.as_ptr() as *const FileMetadata) };

                // 1. メタデータ内のファイル名先頭を0にして「削除済み」とマーク
                meta.filename[0] = 0;

                let mut meta_buf = [0u8; DATA_SIZE_PER_SECTOR];
                unsafe {
                    core::ptr::copy_nonoverlapping(
                        &meta as *const FileMetadata as *const u8,
                        meta_buf.as_mut_ptr(),
                        core::mem::size_of::<FileMetadata>(),
                    );
                }
                self.device.write_sector(meta_sector as usize, &meta_buf)?;

                // 2. エクステントが指す全データセクタを解放する。
                if let Some(extents) = self.collect_extents(&meta) {
                    for sec in Self::extents_to_sectors(&extents) {
                        self.deallocate_sector(sec as u32);
                    }
                }

                // 2b. 溢れエクステントのチェーン自体も解放する
                //     （漏らすとセクタリークになる）。
                let mut next = meta.overflow_sector;
                while next != 0 {
                    let mut buf = [0u8; DATA_SIZE_PER_SECTOR];
                    let following = if self.device.read_sector(next as usize, &mut buf).is_ok() {
                        u64::from_le_bytes([
                            buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6], buf[7],
                        ])
                    } else {
                        0
                    };
                    self.deallocate_sector(next as u32);
                    next = following;
                }

                // 3. メタデータセクタ自身の deallocate (B-Treeからキーが削除されないため、dangling pointer化を防ぐ目的でメタデータセクタは解放せずにゴミとして残す)
                // self.deallocate_sector(meta_sector);

                println!(
                    "  SylFS: File '{}' deallocated and deleted successfully.",
                    filename
                );
                return Ok(());
            }
        }
        Err("delete_file: file not found")
    }

    /// プレフィックス(ディレクトリパス等)で始まるファイルを一覧取得します
    pub fn list_dir(&mut self, prefix: &str) -> Vec<FileMetadata> {
        let mut results = Vec::new();
        let all_files = self.list_files();
        for meta in all_files {
            if meta.get_filename().starts_with(prefix) {
                results.push(meta);
            }
        }
        results
    }
}

/// SylFS 自己テスト（CI スモークの判定マーカー `FS_SELFTEST`）。
/// グローバル FS には一切触れず、専用の RAM デバイス上で
/// ①COW B-Tree が分割後も全キー上書き整合を保つこと（分離キー上書きで部分木が壊れる回帰の捕捉）、
/// ②二重化レイヤがプライマリ破損をミラーから自己修復し、両系破損時のみ失敗すること、を検証する。
pub fn selftest() -> (u32, u32) {
    let mut pass = 0u32;
    let mut total = 0u32;

    // --- 1. COW B-Tree: 分割を強制し、全キーを上書きしても全件正しく引けること ---
    {
        let mut dev = MirroredBlockDevice::new(RAMDisk::new(1024 * 1024));
        let mut next_sec: u32 = 10; // ビットマップを介さない単純払い出し（テスト専用）
        let mut btree = CowBTree::new(0);
        const N: u32 = 40; // MAX_KEYS(24) を超え、複数回の分割を誘発する

        let make_key = |i: u32| -> [u8; 16] {
            let mut k = [0u8; 16];
            k[..4].copy_from_slice(&i.to_be_bytes());
            k
        };

        // 初回挿入（値 = 2000+i）
        let mut ok = true;
        for i in 0..N {
            let key = make_key(i);
            let mut alloc = || {
                let s = next_sec;
                next_sec += 1;
                s
            };
            if btree.insert(&mut dev, &key, 2000 + i, &mut alloc).is_err() {
                ok = false;
                break;
            }
        }
        total += 1;
        if ok {
            pass += 1;
        }

        // 全キーを上書き（値 = 3000+i）。分離キーへ昇格したキーの上書きを含む。
        let mut ok2 = true;
        for i in 0..N {
            let key = make_key(i);
            let mut alloc = || {
                let s = next_sec;
                next_sec += 1;
                s
            };
            if btree.insert(&mut dev, &key, 3000 + i, &mut alloc).is_err() {
                ok2 = false;
                break;
            }
        }
        total += 1;
        if ok2 {
            pass += 1;
        }

        // 全キーが「更新後の値」で引けること（部分木喪失が無いこと）
        let mut all_ok = true;
        for i in 0..N {
            let key = make_key(i);
            if btree.search(&mut dev, &key) != Some(3000 + i) {
                all_ok = false;
            }
        }
        total += 1;
        if all_ok {
            pass += 1;
        }
    }

    // --- 2. 二重化レイヤ: 自己修復と両系破損検知 ---
    {
        let mut dev = MirroredBlockDevice::new(RAMDisk::new(64 * 1024));
        let sector = 5usize;
        let payload = b"SylFS dual-redundancy selftest payload";
        // 準備の書き込み自体が失敗していると、以降の判定は「何を測ったのか
        // 分からない失敗」になる。準備段階も 1 項目として数える。
        total += 1;
        if dev.write_sector(sector, payload).is_ok() {
            pass += 1;
        }

        // プライマリのみ破損 → ミラーから読み出し成功＆内容一致（自己修復）
        let _ = dev.force_corrupt_raw_sector(sector);
        let mut buf = [0u8; DATA_SIZE_PER_SECTOR];
        let healed = dev.read_sector(sector, &mut buf).is_ok() && &buf[..payload.len()] == payload;
        total += 1;
        if healed {
            pass += 1;
        }

        // 修復後はプライマリ単体でも再読込できること
        let mut buf2 = [0u8; DATA_SIZE_PER_SECTOR];
        let reread =
            dev.read_sector(sector, &mut buf2).is_ok() && &buf2[..payload.len()] == payload;
        total += 1;
        if reread {
            pass += 1;
        }

        // 両系破損は復旧不能（Err）であること
        let mirror = sector + dev.total_usable_sectors();
        let _ = dev.force_corrupt_raw_sector(sector);
        let _ = dev.force_corrupt_raw_sector(mirror);
        let mut buf3 = [0u8; DATA_SIZE_PER_SECTOR];
        total += 1;
        if dev.read_sector(sector, &mut buf3).is_err() {
            pass += 1;
        }
    }

    (pass, total)
}