use crate::bytes::{le_u16, le_u32, le_u64};
use crate::error::RefsError;
use crate::metablock::REFS_METADATA_PAGE_SIZE;
pub const REFS_ROOT_DIRECTORY_ID: u64 = 0x0000_0600;
const NODE_HEADER_OFFSET_FIELD: usize = 0x50;
const NODE_HEADER_LEN: usize = 32;
const MAX_RECORDS: usize = REFS_METADATA_PAGE_SIZE / 4;
#[derive(Debug)]
#[non_exhaustive]
pub struct MinstoreRow<'a> {
pub key: &'a [u8],
pub value: &'a [u8],
pub flags: u16,
}
#[derive(Debug)]
#[non_exhaustive]
pub struct MinstorePage<'a> {
page: &'a [u8],
node_header: usize,
level: u8,
flags: u8,
record_offsets: usize,
record_count: usize,
}
impl<'a> MinstorePage<'a> {
pub fn parse(data: &'a [u8], offset: u64) -> Result<Self, RefsError> {
let _ = offset;
if data.len() < NODE_HEADER_OFFSET_FIELD + 4 {
return Err(RefsError::Truncated {
structure: "Minstore node-header-offset field",
need: NODE_HEADER_OFFSET_FIELD + 4,
have: data.len(),
});
}
let rel = le_u32(data, NODE_HEADER_OFFSET_FIELD) as usize;
let node_header = NODE_HEADER_OFFSET_FIELD.saturating_add(rel);
if node_header
.checked_add(NODE_HEADER_LEN)
.is_none_or(|end| end > data.len())
{
return Err(RefsError::Truncated {
structure: "Minstore node header",
need: node_header.saturating_add(NODE_HEADER_LEN),
have: data.len(),
});
}
let level = data.get(node_header + 12).copied().unwrap_or(0);
let flags = data.get(node_header + 13).copied().unwrap_or(0);
let roff_rel = le_u32(data, node_header + 16) as usize;
let claimed = le_u32(data, node_header + 20) as usize;
let record_offsets = node_header.saturating_add(roff_rel);
let capacity = data.len().saturating_sub(record_offsets) / 4;
let record_count = claimed.min(capacity).min(MAX_RECORDS);
Ok(Self {
page: data,
node_header,
level,
flags,
record_offsets,
record_count,
})
}
#[must_use]
pub fn level(&self) -> u8 {
self.level
}
#[must_use]
pub fn is_leaf(&self) -> bool {
self.level == 0 && !self.is_branch()
}
#[must_use]
pub fn is_branch(&self) -> bool {
self.flags & 0x01 != 0
}
pub fn rows(&self) -> impl Iterator<Item = MinstoreRow<'a>> + '_ {
(0..self.record_count).filter_map(move |i| self.row(i))
}
fn row(&self, i: usize) -> Option<MinstoreRow<'a>> {
let off_pos = self.record_offsets.checked_add(i.checked_mul(4)?)?;
let raw = le_u32(self.page, off_pos);
let rec = self.node_header.checked_add((raw & 0xffff) as usize)?;
if rec.checked_add(14)? > self.page.len() {
return None;
}
let key_off = le_u16(self.page, rec + 4) as usize;
let key_len = le_u16(self.page, rec + 6) as usize;
let flags = le_u16(self.page, rec + 8);
let val_off = le_u16(self.page, rec + 10) as usize;
let val_len = le_u16(self.page, rec + 12) as usize;
let key_start = rec.checked_add(key_off)?;
let key_end = key_start.checked_add(key_len)?;
let val_start = rec.checked_add(val_off)?;
let val_end = val_start.checked_add(val_len)?;
let key = self.page.get(key_start..key_end)?;
let value = self.page.get(val_start..val_end)?;
Some(MinstoreRow { key, value, flags })
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub struct PageRef {
pub block_number: u64,
}
#[derive(Debug)]
#[non_exhaustive]
pub struct ObjectTable<'a> {
node: MinstorePage<'a>,
}
impl<'a> ObjectTable<'a> {
const KEY_ID_OFFSET: usize = 8;
const VALUE_BLOCK_REF_OFFSET: usize = 0x20;
pub fn parse(data: &'a [u8], offset: u64) -> Result<Self, RefsError> {
Ok(Self {
node: MinstorePage::parse(data, offset)?,
})
}
#[must_use]
pub fn lookup(&self, object_id: u64) -> Option<PageRef> {
self.node.rows().find_map(|row| {
let id_bytes = row.key.get(Self::KEY_ID_OFFSET..Self::KEY_ID_OFFSET + 8)?;
let id = le_u64(id_bytes, 0);
if id != object_id {
return None;
}
let block = row
.value
.get(Self::VALUE_BLOCK_REF_OFFSET..Self::VALUE_BLOCK_REF_OFFSET + 8)
.map(|b| le_u64(b, 0))?;
Some(PageRef {
block_number: block,
})
})
}
}