use crate::bytes::le_u64;
use crate::error::RefsError;
use crate::metablock::REFS_METADATA_PAGE_SIZE;
use crate::minstore::MinstorePage;
const CLUSTER_SIZE: u64 = 4096;
const CONTAINER_LCN_OFFSET: usize = 144;
const CONTAINER_CLUSTER_COUNT_OFFSET: usize = 152;
const CONTAINER_RECORD_VALUE_LEN: usize = 160;
#[must_use]
pub fn decompose_virtual_block(vblock: u64, band_clusters: u64) -> (u64, u64) {
if band_clusters == 0 {
return (vblock, 0);
}
(vblock / band_clusters, vblock % band_clusters)
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub struct ContainerRecord {
pub band_id: u64,
pub physical_lcn: u64,
pub cluster_count: u64,
}
#[derive(Debug)]
#[non_exhaustive]
pub struct ContainerTable<'a> {
node: MinstorePage<'a>,
}
impl<'a> ContainerTable<'a> {
pub fn parse(data: &'a [u8], offset: u64) -> Result<Self, RefsError> {
Ok(Self {
node: MinstorePage::parse(data, offset)?,
})
}
pub fn records(&self) -> impl Iterator<Item = ContainerRecord> + '_ {
self.node.rows().filter_map(|row| {
if row.value.len() < CONTAINER_RECORD_VALUE_LEN {
return None;
}
let band_id = le_u64(row.value, 0);
let physical_lcn = le_u64(row.value, CONTAINER_LCN_OFFSET);
let cluster_count = le_u64(row.value, CONTAINER_CLUSTER_COUNT_OFFSET);
Some(ContainerRecord {
band_id,
physical_lcn,
cluster_count,
})
})
}
#[must_use]
pub fn physical_base(&self, band_id: u64) -> Option<u64> {
self.records()
.find(|r| r.band_id == band_id)
.map(|r| r.physical_lcn)
}
#[must_use]
pub fn cluster_count(&self, band_id: u64) -> Option<u64> {
self.records()
.find(|r| r.band_id == band_id)
.map(|r| r.cluster_count)
}
}
#[derive(Debug, Clone)]
#[non_exhaustive]
pub struct ContainerResolver {
band_clusters: u64,
base: Vec<(u64, u64)>,
}
const MSB_SIGNATURE: &[u8; 4] = b"MSB+";
const SELF_BLOCK_OFFSET: usize = 0x20;
impl ContainerResolver {
#[must_use]
pub fn from_resident_image(image: &[u8], band_clusters: u64) -> Self {
let mut base: Vec<(u64, u64)> = Vec::new();
if band_clusters == 0 {
return Self {
band_clusters,
base,
};
}
let cluster = CLUSTER_SIZE as usize;
let clusters = image.len() / cluster;
for c in 0..clusters {
let off = c * cluster;
if off + REFS_METADATA_PAGE_SIZE > image.len() {
break;
}
if &image[off..off + 4] != MSB_SIGNATURE {
continue;
}
let self_block = le_u64(image, off + SELF_BLOCK_OFFSET);
let (idx, off_in_band) = decompose_virtual_block(self_block, band_clusters);
let phys_cluster = c as u64;
let Some(band_base) = phys_cluster.checked_sub(off_in_band) else {
continue;
};
if !base.iter().any(|&(i, _)| i == idx) {
base.push((idx, band_base));
}
}
Self {
band_clusters,
base,
}
}
#[must_use]
fn base_of(&self, index: u64) -> Option<u64> {
self.base
.iter()
.find(|&&(i, _)| i == index)
.map(|&(_, b)| b)
}
#[must_use]
pub fn resolve_virtual(&self, vblock: u64) -> Option<u64> {
let (idx, off) = decompose_virtual_block(vblock, self.band_clusters);
let base = self.base_of(idx)?;
let cluster = base.checked_add(off)?;
cluster.checked_mul(CLUSTER_SIZE)
}
pub fn resolve_virtual_checked(&self, vblock: u64) -> Result<u64, RefsError> {
self.resolve_virtual(vblock)
.ok_or(RefsError::UnresolvedVirtualBlock { block: vblock })
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn decompose_zero_band_clusters_never_divides_by_zero() {
assert_eq!(decompose_virtual_block(80_384, 0), (80_384, 0));
}
#[test]
fn resolver_zero_band_clusters_is_empty_and_resolves_nothing() {
let image = vec![0u8; 64 * 4096];
let resolver = ContainerResolver::from_resident_image(&image, 0);
assert!(resolver.resolve_virtual(80_384).is_none());
assert!(matches!(
resolver.resolve_virtual_checked(80_384),
Err(RefsError::UnresolvedVirtualBlock { block: 80_384 })
));
}
#[test]
fn container_records_skip_short_values() {
let page = build_short_value_page();
let ct = ContainerTable::parse(&page, 0).expect("parses");
assert_eq!(
ct.records().count(),
0,
"short-value rows are not container records"
);
assert_eq!(ct.physical_base(1), None);
assert_eq!(ct.cluster_count(1), None);
}
#[test]
fn resolver_skips_inconsistent_page_whose_offset_exceeds_its_cluster() {
const CLUSTER: usize = 4096;
let band_clusters = 16_384u64;
let mut image = vec![0u8; 64 * CLUSTER];
image[0..4].copy_from_slice(b"MSB+");
image[0x20..0x28].copy_from_slice(&5u64.to_le_bytes());
let resolver = ContainerResolver::from_resident_image(&image, band_clusters);
assert!(
resolver.resolve_virtual(5).is_none(),
"an inconsistent page must not seed a base map entry"
);
}
fn build_short_value_page() -> Vec<u8> {
const PAGE: usize = REFS_METADATA_PAGE_SIZE;
let mut page = vec![0u8; PAGE];
page[0..4].copy_from_slice(b"MSB+");
let node_hdr = 0x100usize;
let nho_field = 0x50usize;
page[nho_field..nho_field + 4]
.copy_from_slice(&((node_hdr - nho_field) as u32).to_le_bytes());
let rec = node_hdr + 32;
let key = vec![0u8; 8];
let value = vec![0u8; 16];
let key_off = 16u16;
let val_off = key_off + key.len() as u16;
let rec_size = (val_off as usize + value.len()) as u32;
page[rec..rec + 4].copy_from_slice(&rec_size.to_le_bytes());
page[rec + 4..rec + 6].copy_from_slice(&key_off.to_le_bytes());
page[rec + 6..rec + 8].copy_from_slice(&(key.len() as u16).to_le_bytes());
page[rec + 8..rec + 10].copy_from_slice(&0u16.to_le_bytes());
page[rec + 10..rec + 12].copy_from_slice(&val_off.to_le_bytes());
page[rec + 12..rec + 14].copy_from_slice(&(value.len() as u16).to_le_bytes());
page[rec + key_off as usize..rec + key_off as usize + key.len()].copy_from_slice(&key);
page[rec + val_off as usize..rec + val_off as usize + value.len()].copy_from_slice(&value);
let roff_start_abs = node_hdr + 0x2000;
page[roff_start_abs..roff_start_abs + 4]
.copy_from_slice(&(0xffff_0000u32 | ((rec - node_hdr) as u32 & 0xffff)).to_le_bytes());
let nh = node_hdr;
page[nh + 16..nh + 20].copy_from_slice(&((roff_start_abs - node_hdr) as u32).to_le_bytes());
page[nh + 20..nh + 24].copy_from_slice(&1u32.to_le_bytes());
page
}
}