#[derive(Clone, Copy, PartialEq, Eq, Debug, Default)]
#[non_exhaustive]
pub enum CsumScheme {
#[default]
None,
Crc32c,
}
impl CsumScheme {
#[must_use]
pub const fn writes_object_checksums(self) -> bool {
match self {
Self::None => false,
Self::Crc32c => true,
}
}
#[must_use]
pub const fn uninit_bg_semantics(self) -> bool {
match self {
Self::None => false,
Self::Crc32c => true,
}
}
}
pub trait Checksummer: crate::sealed::Sealed {
fn scheme(&self) -> CsumScheme;
fn base_seed(&self) -> u32;
fn crc32c(&self, seed: u32, data: &[u8]) -> u32;
}
#[derive(Clone, Copy, Debug, Default)]
pub struct NullCsum;
impl crate::sealed::Sealed for NullCsum {}
impl Checksummer for NullCsum {
fn scheme(&self) -> CsumScheme {
CsumScheme::None
}
fn base_seed(&self) -> u32 {
0
}
fn crc32c(&self, _seed: u32, _data: &[u8]) -> u32 {
0
}
}
#[derive(Clone, Copy, Debug)]
pub struct Crc32c {
base_seed: u32,
}
impl Crc32c {
#[must_use]
pub fn new(uuid: &[u8; 16]) -> Self {
Self {
base_seed: crate::crc32c::crc32c(!0, uuid),
}
}
#[must_use]
pub fn with_seed(base_seed: u32) -> Self {
Self { base_seed }
}
}
impl crate::sealed::Sealed for Crc32c {}
impl Checksummer for Crc32c {
fn scheme(&self) -> CsumScheme {
CsumScheme::Crc32c
}
fn base_seed(&self) -> u32 {
self.base_seed
}
fn crc32c(&self, seed: u32, data: &[u8]) -> u32 {
crate::crc32c::crc32c(seed, data)
}
}
pub(crate) fn inode_seed(csum: &dyn Checksummer, ino: u32, generation: u32) -> u32 {
let c = csum.crc32c(csum.base_seed(), &ino.to_le_bytes());
csum.crc32c(c, &generation.to_le_bytes())
}
pub(crate) fn group_descriptor(csum: &dyn Checksummer, group: u32, bytes: &[u8]) -> u16 {
let c = csum.crc32c(csum.base_seed(), &group.to_le_bytes());
(csum.crc32c(c, bytes) & 0xffff) as u16
}
pub(crate) fn group_descriptor_crc16(uuid: &[u8; 16], group: u32, desc: &[u8]) -> u16 {
let field = crate::ondisk::GroupDescriptor::CHECKSUM_OFFSET;
let after = desc.get(field + 2..).unwrap_or_default();
[
uuid.as_slice(),
&group.to_le_bytes(),
&desc[..field.min(desc.len())],
after,
]
.iter()
.flat_map(|part| part.iter())
.fold(0xFFFF_u16, |crc, &byte| {
(0..8).fold(crc ^ u16::from(byte), |c, _| {
if c & 1 == 0 {
c >> 1
} else {
(c >> 1) ^ 0xA001
}
})
})
}
pub(crate) fn inode(
csum: &dyn Checksummer,
number: u32,
generation: u32,
bytes: &[u8],
has_hi: bool,
) -> u32 {
let c = csum.crc32c(inode_seed(csum, number, generation), bytes);
if has_hi { c } else { c & 0xffff }
}
pub(crate) fn mmp_block(csum: &dyn Checksummer, record: &[u8]) -> u32 {
csum.crc32c(
csum.base_seed(),
&record[..crate::ondisk::MMP_CHECKSUM_OFFSET],
)
}
pub(crate) fn bitmap(csum: &dyn Checksummer, covered: &[u8]) -> u32 {
csum.crc32c(csum.base_seed(), covered)
}
pub(crate) const fn block_bitmap_len(blocks_per_group: u32) -> usize {
(blocks_per_group / 8) as usize
}
pub(crate) const fn inode_bitmap_len(inodes_per_group: u32) -> usize {
inodes_per_group.div_ceil(8) as usize
}
pub(crate) fn orphan_block(
csum: &dyn Checksummer,
ino: u32,
generation: u32,
block: u64,
entries: &[u8],
) -> u32 {
let c = csum.crc32c(inode_seed(csum, ino, generation), &block.to_le_bytes());
csum.crc32c(c, entries)
}
pub(crate) fn xattr_block(csum: &dyn Checksummer, block: u64, bytes: &[u8]) -> u32 {
let c = csum.crc32c(csum.base_seed(), &block.to_le_bytes());
csum.crc32c(c, bytes)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_scheme_answers_the_two_questions_separately() {
assert!(!CsumScheme::None.writes_object_checksums());
assert!(!CsumScheme::None.uninit_bg_semantics());
assert!(CsumScheme::Crc32c.writes_object_checksums());
assert!(CsumScheme::Crc32c.uninit_bg_semantics());
assert_eq!(CsumScheme::default(), CsumScheme::None);
}
#[test]
fn null_csum_is_disabled_and_zero() {
let c = NullCsum;
assert_eq!(c.scheme(), CsumScheme::None);
assert_eq!(c.base_seed(), 0);
assert_eq!(c.crc32c(0, b"anything"), 0);
assert_eq!(c.crc32c(0xdead_beef, &[1, 2, 3, 4]), 0);
}
#[test]
fn null_csum_is_usable_as_a_trait_object() {
let c: &dyn Checksummer = &NullCsum;
assert_eq!(c.scheme(), CsumScheme::None);
assert_eq!(c.crc32c(1, b""), 0);
}
#[test]
fn crc32c_seeds_from_the_uuid() {
let uuid = [
0xf0, 0xe1, 0x70, 0x55, 0, 0, 0x40, 0, 0x80, 0, 0, 0, 0, 0, 0, 0,
];
let c = Crc32c::new(&uuid);
assert_eq!(c.scheme(), CsumScheme::Crc32c);
assert_eq!(c.base_seed(), 0x33D2_8425);
assert_eq!(c.crc32c(c.base_seed(), b""), 0x33D2_8425);
}
#[test]
fn crc32c_is_usable_as_a_trait_object() {
let uuid = [0u8; 16];
let c: &dyn Checksummer = &Crc32c::new(&uuid);
assert_eq!(c.scheme(), CsumScheme::Crc32c);
}
#[test]
fn a_recipe_binds_an_object_to_the_identity_it_was_written_under() {
let c = Crc32c::new(&[0u8; 16]);
let bytes = b"the object's own bytes";
assert_ne!(inode_seed(&c, 12, 7), inode_seed(&c, 13, 7));
assert_ne!(inode_seed(&c, 12, 7), inode_seed(&c, 12, 8));
assert_ne!(
orphan_block(&c, 12, 7, 100, bytes),
orphan_block(&c, 12, 7, 101, bytes)
);
assert_ne!(
group_descriptor(&c, 0, bytes),
group_descriptor(&c, 1, bytes)
);
assert_ne!(xattr_block(&c, 100, bytes), xattr_block(&c, 101, bytes));
assert_eq!(inode(&c, 12, 7, bytes, false) >> 16, 0);
assert_eq!(
inode(&c, 12, 7, bytes, false),
inode(&c, 12, 7, bytes, true) & 0xffff
);
let off = NullCsum;
assert_eq!(inode(&off, 12, 7, bytes, true), 0);
assert_eq!(group_descriptor(&off, 0, bytes), 0);
assert_eq!(orphan_block(&off, 12, 7, 100, bytes), 0);
}
#[test]
fn a_block_bitmap_is_covered_whole_and_an_inode_bitmap_rounded_up() {
assert_eq!(block_bitmap_len(32_768), 4096);
assert_eq!(inode_bitmap_len(8192), 1024);
assert_eq!(inode_bitmap_len(8185), 1024);
assert_eq!(inode_bitmap_len(8193), 1025);
}
}