use super::{ParseError, get_u16, get_u32, join64, put_u16, put_u32};
pub const BG_INODE_UNINIT: u16 = 0x0001;
pub const BG_BLOCK_UNINIT: u16 = 0x0002;
pub const BG_INODE_ZEROED: u16 = 0x0004;
#[derive(Clone, Copy, PartialEq, Eq, Debug, Default)]
#[non_exhaustive]
pub struct GroupDescriptor {
pub block_bitmap: u64,
pub inode_bitmap: u64,
pub inode_table: u64,
pub free_blocks_count: u32,
pub free_inodes_count: u32,
pub used_dirs_count: u32,
pub flags: u16,
pub itable_unused: u32,
pub checksum: u16,
pub block_bitmap_csum: u32,
pub inode_bitmap_csum: u32,
}
impl GroupDescriptor {
pub const SIZE_32: usize = 32;
pub const SIZE_64: usize = 64;
pub const CHECKSUM_OFFSET: usize = 0x1e;
pub fn write_to(&self, buf: &mut [u8], desc_size: usize) -> Result<(), ParseError> {
Self::check_desc_size(desc_size)?;
if buf.len() < desc_size {
return Err(ParseError::TooShort {
structure: "GroupDescriptor",
need: desc_size,
got: buf.len(),
});
}
put_u32(buf, 0x00, self.block_bitmap as u32);
put_u32(buf, 0x04, self.inode_bitmap as u32);
put_u32(buf, 0x08, self.inode_table as u32);
put_u16(buf, 0x0c, self.free_blocks_count as u16);
put_u16(buf, 0x0e, self.free_inodes_count as u16);
put_u16(buf, 0x10, self.used_dirs_count as u16);
put_u16(buf, 0x12, self.flags);
put_u16(buf, 0x18, self.block_bitmap_csum as u16);
put_u16(buf, 0x1a, self.inode_bitmap_csum as u16);
put_u16(buf, 0x1c, self.itable_unused as u16);
put_u16(buf, 0x1e, self.checksum);
if desc_size >= Self::SIZE_64 {
put_u32(buf, 0x20, (self.block_bitmap >> 32) as u32);
put_u32(buf, 0x24, (self.inode_bitmap >> 32) as u32);
put_u32(buf, 0x28, (self.inode_table >> 32) as u32);
put_u16(buf, 0x2c, (self.free_blocks_count >> 16) as u16);
put_u16(buf, 0x2e, (self.free_inodes_count >> 16) as u16);
put_u16(buf, 0x30, (self.used_dirs_count >> 16) as u16);
put_u16(buf, 0x32, (self.itable_unused >> 16) as u16);
put_u16(buf, 0x38, (self.block_bitmap_csum >> 16) as u16);
put_u16(buf, 0x3a, (self.inode_bitmap_csum >> 16) as u16);
}
Ok(())
}
pub fn read_from(buf: &[u8], desc_size: usize) -> Result<Self, ParseError> {
Self::check_desc_size(desc_size)?;
if buf.len() < desc_size {
return Err(ParseError::TooShort {
structure: "GroupDescriptor",
need: desc_size,
got: buf.len(),
});
}
let (bb_hi, ib_hi, it_hi, fb_hi, fi_hi, ud_hi, iu_hi, bbc_hi, ibc_hi) =
if desc_size >= Self::SIZE_64 {
(
get_u32(buf, 0x20),
get_u32(buf, 0x24),
get_u32(buf, 0x28),
get_u16(buf, 0x2c),
get_u16(buf, 0x2e),
get_u16(buf, 0x30),
get_u16(buf, 0x32),
get_u16(buf, 0x38),
get_u16(buf, 0x3a),
)
} else {
(0, 0, 0, 0, 0, 0, 0, 0, 0)
};
Ok(Self {
block_bitmap: join64(get_u32(buf, 0x00), bb_hi),
inode_bitmap: join64(get_u32(buf, 0x04), ib_hi),
inode_table: join64(get_u32(buf, 0x08), it_hi),
free_blocks_count: u32::from(get_u16(buf, 0x0c)) | (u32::from(fb_hi) << 16),
free_inodes_count: u32::from(get_u16(buf, 0x0e)) | (u32::from(fi_hi) << 16),
used_dirs_count: u32::from(get_u16(buf, 0x10)) | (u32::from(ud_hi) << 16),
flags: get_u16(buf, 0x12),
itable_unused: u32::from(get_u16(buf, 0x1c)) | (u32::from(iu_hi) << 16),
checksum: get_u16(buf, 0x1e),
block_bitmap_csum: u32::from(get_u16(buf, 0x18)) | (u32::from(bbc_hi) << 16),
inode_bitmap_csum: u32::from(get_u16(buf, 0x1a)) | (u32::from(ibc_hi) << 16),
})
}
fn check_desc_size(desc_size: usize) -> Result<(), ParseError> {
if desc_size < Self::SIZE_32 {
return Err(ParseError::InvalidField {
structure: "GroupDescriptor",
field: "s_desc_size",
value: desc_size as u64,
});
}
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
fn sample() -> GroupDescriptor {
GroupDescriptor {
block_bitmap: 5,
inode_bitmap: 9,
inode_table: 13,
free_blocks_count: 30701,
free_inodes_count: 8181,
used_dirs_count: 2,
flags: BG_INODE_ZEROED,
itable_unused: 0,
checksum: 0,
block_bitmap_csum: 0,
inode_bitmap_csum: 0,
}
}
#[test]
fn round_trips_64_byte_form() {
let d = sample();
let mut buf = [0u8; GroupDescriptor::SIZE_64];
d.write_to(&mut buf, GroupDescriptor::SIZE_64).unwrap();
assert_eq!(
GroupDescriptor::read_from(&buf, GroupDescriptor::SIZE_64).unwrap(),
d
);
}
#[test]
fn matches_ground_truth_group0_bytes() {
let d = sample();
let mut buf = [0u8; GroupDescriptor::SIZE_64];
d.write_to(&mut buf, GroupDescriptor::SIZE_64).unwrap();
assert_eq!(&buf[0x00..0x04], &5u32.to_le_bytes());
assert_eq!(&buf[0x04..0x08], &9u32.to_le_bytes());
assert_eq!(&buf[0x08..0x0c], &13u32.to_le_bytes());
assert_eq!(get_u16(&buf, 0x0c), 30701);
assert_eq!(get_u16(&buf, 0x0e), 8181);
assert_eq!(get_u16(&buf, 0x10), 2);
assert_eq!(get_u16(&buf, 0x12), 0x0004);
}
#[test]
fn round_trips_high_halves() {
let d = GroupDescriptor {
block_bitmap: 0x1_0000_0005,
inode_bitmap: 0x2_0000_0009,
inode_table: 0x3_0000_000d,
free_blocks_count: 0x1_2345,
free_inodes_count: 0x2_3456,
used_dirs_count: 0x0003,
flags: BG_INODE_ZEROED,
itable_unused: 0x1_0000,
checksum: 0xabcd,
block_bitmap_csum: 0,
inode_bitmap_csum: 0,
};
let mut buf = [0u8; GroupDescriptor::SIZE_64];
d.write_to(&mut buf, GroupDescriptor::SIZE_64).unwrap();
assert_eq!(
GroupDescriptor::read_from(&buf, GroupDescriptor::SIZE_64).unwrap(),
d
);
}
#[test]
fn thirty_two_byte_form_drops_high_halves() {
let d = sample();
let mut buf = [0u8; GroupDescriptor::SIZE_32];
d.write_to(&mut buf, GroupDescriptor::SIZE_32).unwrap();
let back = GroupDescriptor::read_from(&buf, GroupDescriptor::SIZE_32).unwrap();
assert_eq!(back, d);
}
#[test]
fn rejects_short_buffer() {
let d = sample();
let mut buf = [0u8; 16];
assert!(matches!(
d.write_to(&mut buf, GroupDescriptor::SIZE_64),
Err(ParseError::TooShort { .. })
));
}
#[test]
fn rejects_a_descriptor_size_below_the_smallest_form() {
let d = sample();
let mut buf = [0u8; GroupDescriptor::SIZE_64];
for desc_size in [0, 1, 16, GroupDescriptor::SIZE_32 - 1] {
assert!(
matches!(
d.write_to(&mut buf, desc_size),
Err(ParseError::InvalidField {
structure: "GroupDescriptor",
field: "s_desc_size",
..
})
),
"write_to accepted desc_size {desc_size}"
);
assert!(
matches!(
GroupDescriptor::read_from(&buf, desc_size),
Err(ParseError::InvalidField {
structure: "GroupDescriptor",
field: "s_desc_size",
..
})
),
"read_from accepted desc_size {desc_size}"
);
}
assert!(matches!(
GroupDescriptor::read_from(&[0u8; 16], 16),
Err(ParseError::InvalidField { .. })
));
}
#[test]
fn round_trips_a_width_between_the_two_forms() {
let d = sample();
let mut buf = [0u8; GroupDescriptor::SIZE_64];
for desc_size in [GroupDescriptor::SIZE_32, 40, GroupDescriptor::SIZE_64 - 1] {
d.write_to(&mut buf, desc_size)
.expect("a serializable width");
assert_eq!(
GroupDescriptor::read_from(&buf, desc_size).expect("read back"),
d,
"desc_size {desc_size}"
);
}
}
}