Struct ReaderSuperblock 

#[non_exhaustive]
pub struct ReaderSuperblock {

    pub version: UfsVersion,
    pub endian: Endian,
    pub sblkno: i32,
    pub cblkno: i32,
    pub iblkno: i32,
    pub dblkno: i32,
    pub ncg: u32,
    pub bsize: i32,
    pub fsize: i32,
    pub frag: i32,
    pub bshift: i32,
    pub fshift: i32,
    pub fragshift: i32,
    pub fsbtodb: i32,
    pub sbsize: i32,
    pub nindir: i32,
    pub inopb: u32,
    pub ipg: i32,
    pub fpg: i32,
    pub size: i64,
    pub dsize: i64,
    pub csaddr: i64,
    pub sblockloc: i64,
    pub maxsymlinklen: i32,
}

Parsed UFS superblock — geometry and addressing fields the cylinder-group and inode decode (P1) need.

This carries the subset of struct fs the reader currently uses; it is #[non_exhaustive] so later phases add fields without a breaking change.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

version: UfsVersion

On-disk version (UFS1 vs UFS2), from the magic.

endian: Endian

On-disk byte order, from the magic.

sblkno: i32

fs_sblkno — superblock offset within a cylinder group (frags).

cblkno: i32

fs_cblkno — cylinder-group-block offset within a cg (frags).

iblkno: i32

fs_iblkno — inode-blocks offset within a cg (frags).

dblkno: i32

fs_dblkno — first data-block offset within a cg (frags).

ncg: u32

fs_ncg — number of cylinder groups.

bsize: i32

fs_bsize — basic block size in bytes.

fsize: i32

fs_fsize — fragment size in bytes.

frag: i32

fs_frag — number of fragments in a block (bsize / fsize).

bshift: i32

fs_bshift — log2(bsize).

fshift: i32

fs_fshift — log2(fsize).

fragshift: i32

fs_fragshift — log2(frag).

fsbtodb: i32

fs_fsbtodb — fsblock→disk-block shift constant.

sbsize: i32

fs_sbsize — actual on-disk superblock size in bytes.

nindir: i32

fs_nindir — pointers per indirect block.

inopb: u32

fs_inopb — inodes per block.

ipg: i32

fs_ipg — inodes per cylinder group.

fpg: i32

fs_fpg — fragments per cylinder group.

size: i64

Total size of the filesystem in fragments (fs_size on UFS2, the 32-bit fs_old_size on UFS1).

dsize: i64

Data-region size in fragments (fs_dsize / fs_old_dsize).

csaddr: i64

fs_csaddr — fragment address of the cylinder-summary area (UFS2).

sblockloc: i64

fs_sblockloc — the byte offset at which this superblock records itself (self-locating; SBLOCK_UFS2 on UFS2). 0 on UFS1 (field absent).

maxsymlinklen: i32

fs_maxsymlinklen — inline (fast) symlink length threshold.

Implementations

impl Superblock

pub fn parse(data: &[u8]) -> Result<Superblock, UfsError>

Parse a superblock from the start of data (i.e. data begins at the superblock, not at the filesystem start — callers slice from SBLOCK_UFS1/SBLOCK_UFS2).

Detects the UFS version and byte order from fs_magic (offset 1372) by trying both interpretations against both known magics, then decodes the geometry in the resolved byte order.

Errors

• UfsError::BadMagic if the value at offset 1372 is neither UFS magic in either byte order — the offending bytes are carried.
• UfsError::Truncated if data is shorter than the fields read.
• UfsError::ImpossibleGeometry if a geometry field is out of range.

pub fn inode_size(&self) -> u32

The inode size in bytes for this version: 128 (UFS1) or 256 (UFS2).

pub fn primary_offset(&self) -> usize

The primary-superblock byte offset for this version from the filesystem start (SBLOCK_UFS1 / SBLOCK_UFS2).

Trait Implementations

impl Clone for Superblock

fn clone(&self) -> Superblock

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Superblock

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Eq for Superblock

impl PartialEq for Superblock

fn eq(&self, other: &Superblock) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Superblock