rust-fs-ext4 0.8.0

//! Integration test: parse the JBD2 journal superblock from real images built
//! by `chore fixtures` (recipes in test-disks/guest-build-images.sh).
//!
//! Spec reference for the superblock layout: see ext4rs/src/jbd2.rs.
//!
//! We don't rely on `has_journal` feature being the default in these images —
//! if `sb.journal_inode == 0`, we assert that `jbd2::read_superblock` returns
//! Ok(None) instead of failing.

use fs_ext4::block_io::FileDevice;
use fs_ext4::jbd2::{self, JBD2_SUPERBLOCK_V1, JBD2_SUPERBLOCK_V2};
use fs_ext4::Filesystem;
use std::sync::Arc;

fn mount_fixture(image: &str) -> Filesystem {
    let path = fs_ext4_test_support::fixture(env!("CARGO_MANIFEST_DIR"), image);
    let dev = FileDevice::open(&path).unwrap_or_else(|e| panic!("open {path}: {e:?}"));
    Filesystem::mount(Arc::new(dev)).unwrap_or_else(|e| panic!("mount {path}: {e:?}"))
}

#[test]
fn journal_sb_round_trips_on_basic_image() {
    let fs = mount_fixture("ext4-basic.img");

    let sb = jbd2::read_superblock(&fs).expect("read_superblock");

    match sb {
        Some(jsb) => {
            // Type must be V1 or V2.
            assert!(
                matches!(jsb.block_type, JBD2_SUPERBLOCK_V1 | JBD2_SUPERBLOCK_V2),
                "bad block_type {}",
                jsb.block_type
            );
            // Journal block size should match fs block size for an internal journal.
            assert_eq!(
                jsb.block_size,
                fs.sb.block_size(),
                "journal block_size {} != fs block_size {}",
                jsb.block_size,
                fs.sb.block_size()
            );
            // max_len > 0 (mkfs defaults to at least 1024 journal blocks).
            assert!(jsb.max_len > 0, "max_len == 0");
            // first is typically 1 (block 0 is the sb itself).
            assert!(jsb.first >= 1, "first block < 1: {}", jsb.first);
            // errno == 0 for a healthy image.
            assert_eq!(jsb.errno, 0, "journal errno = {}", jsb.errno);
            // Unmounted image should be clean.
            assert!(
                jsb.is_clean(),
                "expected clean journal (start=0), got start={}",
                jsb.start
            );
        }
        None => {
            assert_eq!(fs.sb.journal_inode, 0, "journal_inode != 0 but got None");
        }
    }
}

#[test]
fn journal_sb_on_csum_seed_image() {
    let fs = mount_fixture("ext4-csum-seed.img");
    // ext4-csum-seed.img is built with has_journal.
    let jsb = jbd2::read_superblock(&fs)
        .expect("read_superblock")
        .expect("ext4-csum-seed.img has no journal superblock");
    // On the Pi-style CSUM_SEED image we still expect a valid journal.
    assert!(matches!(
        jsb.block_type,
        JBD2_SUPERBLOCK_V1 | JBD2_SUPERBLOCK_V2
    ));
    assert_eq!(jsb.block_size, fs.sb.block_size());
    assert!(jsb.is_clean());
}

#[test]
fn journal_sb_on_htree_image() {
    let fs = mount_fixture("ext4-htree.img");
    // ext4-htree.img is built with has_journal.
    let jsb = jbd2::read_superblock(&fs)
        .expect("read_superblock")
        .expect("ext4-htree.img has no journal superblock");
    assert!(matches!(
        jsb.block_type,
        JBD2_SUPERBLOCK_V1 | JBD2_SUPERBLOCK_V2
    ));
    assert!(jsb.max_len > 0);
    assert!(jsb.is_clean());
}