use crate::bytes::{be_u16, be_u32, be_u64, u8_at};
use crate::crc::{crc_status, SB_CRC_OFF};
use crate::error::XfsError;
use crate::inode::Inode;
pub const XFS_SB_MAGIC: u32 = 0x5846_5342;
const SB_MIN_LEN: usize = 220;
const XFS_SB_VERSION2_FTYPE: u32 = 0x0000_0200;
const XFS_SB_FEAT_INCOMPAT_FTYPE: u32 = 0x0000_0001;
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub struct Superblock {
pub magic: u32,
pub blocksize: u32,
pub rootino: u64,
pub agblocks: u32,
pub agcount: u32,
pub versionnum: u16,
pub inodesize: u16,
pub inopblock: u16,
pub blocklog: u8,
pub inodelog: u8,
pub inopblog: u8,
pub agblklog: u8,
pub features2: u32,
pub features_incompat: u32,
pub crc_valid: Option<bool>,
}
impl Superblock {
pub fn parse(data: &[u8]) -> Result<Self, XfsError> {
let bytes = [
u8_at(data, 0),
u8_at(data, 1),
u8_at(data, 2),
u8_at(data, 3),
];
let magic = u32::from_be_bytes(bytes);
if magic != XFS_SB_MAGIC {
return Err(XfsError::BadMagic {
found: magic,
bytes,
});
}
if data.len() < SB_MIN_LEN {
return Err(XfsError::Truncated {
structure: "superblock",
need: SB_MIN_LEN,
have: data.len(),
});
}
let versionnum = be_u16(data, 100);
let is_v5 = versionnum & 0x000f == 5;
let crc_valid = crc_status(is_v5, data, SB_CRC_OFF);
Ok(Self {
magic,
blocksize: be_u32(data, 4),
rootino: be_u64(data, 56),
agblocks: be_u32(data, 84),
agcount: be_u32(data, 88),
versionnum,
inodesize: be_u16(data, 104),
inopblock: be_u16(data, 106),
blocklog: u8_at(data, 120),
inodelog: u8_at(data, 122),
inopblog: u8_at(data, 123),
agblklog: u8_at(data, 124),
features2: be_u32(data, 200),
features_incompat: be_u32(data, 216),
crc_valid,
})
}
#[must_use]
pub fn has_ftype(&self) -> bool {
if self.is_v5() {
self.features_incompat & XFS_SB_FEAT_INCOMPAT_FTYPE != 0
} else {
self.features2 & XFS_SB_VERSION2_FTYPE != 0
}
}
#[must_use]
pub fn version(&self) -> u8 {
(self.versionnum & 0x000f) as u8
}
#[must_use]
pub fn is_v5(&self) -> bool {
self.version() == 5
}
#[must_use]
pub fn inode_to_location(&self, ino: u64) -> InodeLocation {
let inopblog = u32::from(self.inopblog);
let agino_bits = u32::from(self.agblklog) + inopblog;
let agno = shr(ino, agino_bits);
let agino = ino & low_mask(agino_bits);
let agblock = shr(agino, inopblog);
let offset = agino & low_mask(inopblog);
let fsblock = agno
.saturating_mul(u64::from(self.agblocks))
.saturating_add(agblock);
let byte_offset = fsblock
.saturating_mul(u64::from(self.blocksize))
.saturating_add(offset.saturating_mul(u64::from(self.inodesize)));
InodeLocation {
agno,
agino,
agblock,
offset,
fsblock,
byte_offset,
}
}
pub fn read_inode(&self, image: &[u8], ino: u64) -> Result<Inode, XfsError> {
let loc = self.inode_to_location(ino);
let start = usize::try_from(loc.byte_offset).unwrap_or(usize::MAX);
let size = usize::from(self.inodesize);
let end = start.saturating_add(size);
let slice = image.get(start..end).ok_or(XfsError::Truncated {
structure: "inode (image slice)",
need: end,
have: image.len(),
})?;
Inode::parse(slice)
}
}
#[inline]
fn shr(value: u64, bits: u32) -> u64 {
value.checked_shr(bits).unwrap_or(0)
}
#[inline]
fn low_mask(bits: u32) -> u64 {
if bits >= 64 {
u64::MAX
} else {
(1u64 << bits) - 1
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct InodeLocation {
pub agno: u64,
pub agino: u64,
pub agblock: u64,
pub offset: u64,
pub fsblock: u64,
pub byte_offset: u64,
}