use crate::bytes::{be_u32, u8_at};
use crate::crc::{crc_status, AGFL_CRC_OFF, AGF_CRC_OFF, AGI_CRC_OFF};
use crate::error::XfsError;
pub const XFS_AGF_MAGIC: u32 = 0x5841_4746;
pub const XFS_AGI_MAGIC: u32 = 0x5841_4749;
pub const XFS_AGFL_MAGIC: u32 = 0x5841_464c;
pub const XFS_AGI_UNLINKED_BUCKETS: usize = 64;
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub struct Agf {
pub magicnum: u32,
pub versionnum: u32,
pub seqno: u32,
pub length: u32,
pub bno_root: u32,
pub cnt_root: u32,
pub rmap_root: u32,
pub bno_level: u32,
pub cnt_level: u32,
pub rmap_level: u32,
pub flfirst: u32,
pub fllast: u32,
pub flcount: u32,
pub freeblks: u32,
pub longest: u32,
pub btreeblks: u32,
pub rmap_blocks: u32,
pub refcount_blocks: u32,
pub refcount_root: u32,
pub refcount_level: u32,
pub crc_valid: Option<bool>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub struct Agi {
pub magicnum: u32,
pub versionnum: u32,
pub seqno: u32,
pub length: u32,
pub count: u32,
pub root: u32,
pub level: u32,
pub freecount: u32,
pub newino: u32,
pub dirino: u32,
pub unlinked: [u32; XFS_AGI_UNLINKED_BUCKETS],
pub free_root: u32,
pub free_level: u32,
pub ino_blocks: u32,
pub fino_blocks: u32,
pub crc_valid: Option<bool>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub struct Agfl {
pub magicnum: Option<u32>,
pub seqno: Option<u32>,
pub bno: Vec<u32>,
pub crc_valid: Option<bool>,
}
const XFS_NULL_AGBLOCK: u32 = 0xffff_ffff;
const AGF_MIN_LEN: usize = 96;
const AGI_UNLINKED_OFF: usize = 40;
const AGI_MIN_LEN: usize = AGI_UNLINKED_OFF + XFS_AGI_UNLINKED_BUCKETS * 4;
fn check_magic(data: &[u8], expected: u32) -> Result<u32, XfsError> {
let bytes = [
u8_at(data, 0),
u8_at(data, 1),
u8_at(data, 2),
u8_at(data, 3),
];
let found = u32::from_be_bytes(bytes);
if found == expected {
Ok(found)
} else {
Err(XfsError::BadMagic { found, bytes })
}
}
impl Agf {
pub fn parse(data: &[u8]) -> Result<Self, XfsError> {
Self::parse_inner(data, None)
}
pub fn parse_verified(data: &[u8], is_v5: bool) -> Result<Self, XfsError> {
Self::parse_inner(data, Some(is_v5))
}
fn parse_inner(data: &[u8], verify: Option<bool>) -> Result<Self, XfsError> {
let magicnum = check_magic(data, XFS_AGF_MAGIC)?;
if data.len() < AGF_MIN_LEN {
return Err(XfsError::Truncated {
structure: "AGF",
need: AGF_MIN_LEN,
have: data.len(),
});
}
let crc_valid = verify.and_then(|is_v5| crc_status(is_v5, data, AGF_CRC_OFF));
Ok(Self {
magicnum,
versionnum: be_u32(data, 4),
seqno: be_u32(data, 8),
length: be_u32(data, 12),
bno_root: be_u32(data, 16),
cnt_root: be_u32(data, 20),
rmap_root: be_u32(data, 24),
bno_level: be_u32(data, 28),
cnt_level: be_u32(data, 32),
rmap_level: be_u32(data, 36),
flfirst: be_u32(data, 40),
fllast: be_u32(data, 44),
flcount: be_u32(data, 48),
freeblks: be_u32(data, 52),
longest: be_u32(data, 56),
btreeblks: be_u32(data, 60),
rmap_blocks: be_u32(data, 80),
refcount_blocks: be_u32(data, 84),
refcount_root: be_u32(data, 88),
refcount_level: be_u32(data, 92),
crc_valid,
})
}
}
impl Agi {
pub fn parse(data: &[u8]) -> Result<Self, XfsError> {
Self::parse_inner(data, None)
}
pub fn parse_verified(data: &[u8], is_v5: bool) -> Result<Self, XfsError> {
Self::parse_inner(data, Some(is_v5))
}
fn parse_inner(data: &[u8], verify: Option<bool>) -> Result<Self, XfsError> {
let magicnum = check_magic(data, XFS_AGI_MAGIC)?;
if data.len() < AGI_MIN_LEN {
return Err(XfsError::Truncated {
structure: "AGI",
need: AGI_MIN_LEN,
have: data.len(),
});
}
let mut unlinked = [0u32; XFS_AGI_UNLINKED_BUCKETS];
for (i, slot) in unlinked.iter_mut().enumerate() {
*slot = be_u32(data, AGI_UNLINKED_OFF + i * 4);
}
let crc_valid = verify.and_then(|is_v5| crc_status(is_v5, data, AGI_CRC_OFF));
Ok(Self {
magicnum,
versionnum: be_u32(data, 4),
seqno: be_u32(data, 8),
length: be_u32(data, 12),
count: be_u32(data, 16),
root: be_u32(data, 20),
level: be_u32(data, 24),
freecount: be_u32(data, 28),
newino: be_u32(data, 32),
dirino: be_u32(data, 36),
unlinked,
free_root: be_u32(data, 328),
free_level: be_u32(data, 332),
ino_blocks: be_u32(data, 336),
fino_blocks: be_u32(data, 340),
crc_valid,
})
}
}
impl Agfl {
pub fn parse_v5(data: &[u8], sectorsize: u32) -> Result<Self, XfsError> {
let magicnum = check_magic(data, XFS_AGFL_MAGIC)?;
if data.len() < AGFL_V5_HEADER_LEN {
return Err(XfsError::Truncated {
structure: "AGFL",
need: AGFL_V5_HEADER_LEN,
have: data.len(),
});
}
let slots = (sectorsize as usize).saturating_sub(AGFL_V5_HEADER_LEN) / 4;
let bno = read_bno_ring(data, AGFL_V5_HEADER_LEN, slots);
let crc_valid = crc_status(true, data, AGFL_CRC_OFF);
Ok(Self {
magicnum: Some(magicnum),
seqno: Some(be_u32(data, 4)),
bno,
crc_valid,
})
}
#[must_use]
pub fn parse_v4(data: &[u8], sectorsize: u32) -> Self {
let slots = (sectorsize as usize) / 4;
let bno = read_bno_ring(data, 0, slots);
Self {
magicnum: None,
seqno: None,
bno,
crc_valid: None,
}
}
}
const AGFL_V5_HEADER_LEN: usize = 36;
fn read_bno_ring(data: &[u8], off: usize, slots: usize) -> Vec<u32> {
(0..slots)
.map(|i| {
let at = off + i * 4;
if at + 4 <= data.len() {
be_u32(data, at)
} else {
XFS_NULL_AGBLOCK
}
})
.collect()
}