use crate::codec::{Reader, Writer};
use crate::meta::{
FillPattern, MetaError, NAME_MAX, RegionKind, RegionName, RegionState, VolumeMeta,
};
pub const VOLUME_META2_LEN: usize = 64;
pub const PAGE_HEADER_LEN: usize = 24;
pub const ENTRY2_LEN: usize = 96;
pub const REGION_HEADER2_LEN: usize = 64;
pub const EXTENT_LEN: usize = 16;
pub const MAX_TABLE_PAGES: u32 = 1 << 30;
pub const FLAG_UNWRITTEN: u8 = 1 << 0;
pub const FLAG_CAPPED: u8 = 1 << 1;
pub const KNOWN_FLAGS: u8 = FLAG_UNWRITTEN | FLAG_CAPPED;
pub const LOG2_RANGE: core::ops::RangeInclusive<u8> = 12..=16;
#[must_use]
pub const fn entries_per_page(log2_table: u8) -> u16 {
let l = if log2_table < 12 {
12
} else if log2_table > 16 {
16
} else {
log2_table
};
let t = 1u32 << l;
((t - 128 - PAGE_HEADER_LEN as u32) / ENTRY2_LEN as u32) as u16
}
#[must_use]
pub const fn max_extents(log2_block: u8) -> usize {
let l = if log2_block < 12 {
12
} else if log2_block > 16 {
16
} else {
log2_block
};
((1usize << l) - 128 - REGION_HEADER2_LEN) / EXTENT_LEN
}
#[must_use]
pub const fn max_object(log2_block: u8) -> usize {
let l = if log2_block < 12 {
12
} else if log2_block > 16 {
16
} else {
log2_block
};
(1usize << l) - 128 - REGION_HEADER2_LEN
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct VolumeMeta2 {
pub base: VolumeMeta,
pub table_pages: u32,
pub entries_per_page: u16,
pub clean_close: bool,
pub flags: u32,
}
impl VolumeMeta2 {
pub fn encode(&self, out: &mut [u8]) -> Result<usize, MetaError> {
let n = self.base.encode(out)?;
let mut w = Writer::new(out.get_mut(n..).ok_or(MetaError::Length)?);
w.u32(self.table_pages)?;
w.u16(self.entries_per_page)?;
w.u8(u8::from(self.clean_close))?;
w.u8(0)?;
w.u32(self.flags)?;
w.u32(0)?;
Ok(n + w.position())
}
pub fn decode(bytes: &[u8]) -> Result<Self, MetaError> {
if bytes.len() != VOLUME_META2_LEN {
return Err(MetaError::Length);
}
let mut r = Reader::new(&bytes[48..]);
let table_pages = r.u32()?;
let entries = r.u16()?;
let clean_close = r.u8()?;
let reserved0 = r.u8()?;
let flags = r.u32()?;
let reserved1 = r.u32()?;
if bytes[32..40].iter().any(|&b| b != 0) {
return Err(MetaError::Field("features"));
}
if flags != 0 {
return Err(MetaError::Field("flags"));
}
let base = VolumeMeta::decode(&bytes[..48])?;
if reserved0 != 0 || reserved1 != 0 {
return Err(MetaError::Field("reserved"));
}
if base.table_offset != 2u64 << base.log2_block_size {
return Err(MetaError::Field("table_offset"));
}
if table_pages == 0 || table_pages >= MAX_TABLE_PAGES {
return Err(MetaError::Field("table_pages"));
}
if entries != entries_per_page(base.log2_table_slot_size) {
return Err(MetaError::Field("entries_per_page"));
}
if clean_close > 1 {
return Err(MetaError::Field("clean_close"));
}
Ok(Self {
base,
table_pages,
entries_per_page: entries,
clean_close: clean_close == 1,
flags,
})
}
pub fn check_file_len(&self, file_len: u64) -> Result<(), MetaError> {
if self.table_end() > file_len {
return Err(MetaError::Field("table_pages"));
}
Ok(())
}
#[must_use]
pub fn table_end(&self) -> u64 {
let b = 1u64 << self.base.log2_block_size;
let t = 1u64 << self.base.log2_table_slot_size;
2 * b + 2 * u64::from(self.table_pages) * t
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct PageHeader {
pub page_index: u32,
pub next_seq: u32,
pub count: u16,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct RawEntry {
pub seq: u32,
pub kind: u8,
pub state: u8,
pub flags: u8,
pub compat_flags: u8,
pub name: [u8; NAME_MAX],
pub tag: u32,
pub extent_count: u16,
reserved: u16,
pub header_a: u64,
pub header_b: u64,
pub data_size: u64,
pub capacity: u64,
pub span_start: u64,
pub span_end: u64,
pub footprint_seq: u64,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Entry2 {
pub seq: u32,
pub kind: RegionKind,
pub flags: u8,
pub compat_flags: u8,
pub name: RegionName,
pub tag: u32,
pub extent_count: u16,
pub header_a: u64,
pub header_b: u64,
pub data_size: u64,
pub capacity: u64,
pub span_start: u64,
pub span_end: u64,
pub footprint_seq: u64,
}
impl Entry2 {
pub fn check_header(&self, region_id: u64, h: &RegionHeader2) -> Result<(), MetaError> {
if h.region_id != region_id {
return Err(MetaError::Field("region_id"));
}
if h.kind != self.kind {
return Err(MetaError::Field("kind"));
}
if h.flags != self.flags {
return Err(MetaError::Field("flags"));
}
if h.state != RegionState::Ready {
return Err(MetaError::Field("state"));
}
let more = if self.kind == RegionKind::Slot { 0 } else { 1 };
let (have, want) = (u32::from(h.extent_count), u32::from(self.extent_count));
if have < want || have > want + more {
return Err(MetaError::Field("extent_count"));
}
if self.data_size % (1u64 << h.log2_block.clamp(9, 16)) != 0 {
return Err(MetaError::Unaligned);
}
Ok(())
}
#[must_use]
pub fn to_raw(&self) -> RawEntry {
let mut name = [0u8; NAME_MAX];
let s = self.name.as_str().as_bytes();
name[..s.len()].copy_from_slice(s);
RawEntry {
seq: self.seq,
kind: self.kind.to_u8(),
state: RegionState::Ready.to_u8(),
flags: self.flags,
compat_flags: self.compat_flags,
name,
tag: self.tag,
extent_count: self.extent_count,
reserved: 0,
header_a: self.header_a,
header_b: self.header_b,
data_size: self.data_size,
capacity: self.capacity,
span_start: self.span_start,
span_end: self.span_end,
footprint_seq: self.footprint_seq,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct EntryLimits {
pub log2_block: u8,
pub table_end: u64,
pub file_len: u64,
pub page_meta_seq: u64,
}
impl RawEntry {
fn read(r: &mut Reader<'_>) -> Result<Self, MetaError> {
Ok(Self {
seq: r.u32()?,
kind: r.u8()?,
state: r.u8()?,
flags: r.u8()?,
compat_flags: r.u8()?,
name: r.array::<NAME_MAX>()?,
tag: r.u32()?,
extent_count: r.u16()?,
reserved: r.u16()?,
header_a: r.u64()?,
header_b: r.u64()?,
data_size: r.u64()?,
capacity: r.u64()?,
span_start: r.u64()?,
span_end: r.u64()?,
footprint_seq: r.u64()?,
})
}
fn write(&self, w: &mut Writer<'_>) -> Result<(), MetaError> {
w.u32(self.seq)?;
w.u8(self.kind)?;
w.u8(self.state)?;
w.u8(self.flags)?;
w.u8(self.compat_flags)?;
w.bytes(&self.name)?;
w.u32(self.tag)?;
w.u16(self.extent_count)?;
w.u16(0)?;
w.u64(self.header_a)?;
w.u64(self.header_b)?;
w.u64(self.data_size)?;
w.u64(self.capacity)?;
w.u64(self.span_start)?;
w.u64(self.span_end)?;
w.u64(self.footprint_seq)?;
Ok(())
}
pub fn check(&self, lim: &EntryLimits) -> Result<Entry2, MetaError> {
if self.flags & !KNOWN_FLAGS != 0 {
return Err(MetaError::Field("flags"));
}
if !LOG2_RANGE.contains(&lim.log2_block) {
return Err(MetaError::Field("log2_block"));
}
let kind = RegionKind::from_u8(self.kind)?;
if RegionState::from_u8(self.state)? != RegionState::Ready {
return Err(MetaError::Field("state"));
}
let name = RegionName::from_padded(self.name)?;
if self.data_size > self.capacity {
return Err(MetaError::Field("data_size"));
}
let block = 1u64 << lim.log2_block;
if self.span_start >= self.span_end || self.span_end > lim.file_len {
return Err(MetaError::Field("span"));
}
if self.capacity > self.span_end - self.span_start {
return Err(MetaError::Field("capacity"));
}
if self.span_start % block != 0 || self.span_end % block != 0 {
return Err(MetaError::Unaligned);
}
for h in [self.header_a, self.header_b] {
if h % block != 0 {
return Err(MetaError::Unaligned);
}
let end = h.checked_add(block).ok_or(MetaError::Field("header"))?;
if h < lim.table_end || h < self.span_start || end > self.span_end {
return Err(MetaError::Field("header"));
}
}
if self.header_a == self.header_b {
return Err(MetaError::Field("header"));
}
if self.footprint_seq == 0 || self.footprint_seq > lim.page_meta_seq {
return Err(MetaError::Field("footprint_seq"));
}
if kind == RegionKind::Slot {
if self.extent_count != 0 || self.capacity != 0 || self.data_size != 0 {
return Err(MetaError::Field("slot"));
}
} else if self.extent_count == 0 {
return Err(MetaError::Field("extent_count"));
} else if self.capacity == 0 {
return Err(MetaError::Field("capacity"));
}
let unit = if kind == RegionKind::Append {
512
} else {
block
};
if self.capacity % block != 0 || self.data_size % unit != 0 {
return Err(MetaError::Unaligned);
}
Ok(Entry2 {
seq: self.seq,
kind,
flags: self.flags,
compat_flags: self.compat_flags,
name,
tag: self.tag,
extent_count: self.extent_count,
header_a: self.header_a,
header_b: self.header_b,
data_size: self.data_size,
capacity: self.capacity,
span_start: self.span_start,
span_end: self.span_end,
footprint_seq: self.footprint_seq,
})
}
#[must_use]
pub fn name(&self) -> Option<RegionName> {
RegionName::from_padded(self.name).ok()
}
#[must_use]
pub fn name_and_kind(&self) -> Option<(RegionName, RegionKind)> {
Some((
RegionName::from_padded(self.name).ok()?,
RegionKind::from_u8(self.kind).ok()?,
))
}
#[must_use]
pub fn reserved_span(&self, lim: &EntryLimits) -> Option<(u64, u64)> {
let block = 1u64 << lim.log2_block.clamp(12, 16);
let start = (self.span_start - self.span_start % block).max(lim.table_end);
let end = self
.span_end
.checked_next_multiple_of(block)
.unwrap_or(u64::MAX)
.min(lim.file_len);
(start < end).then_some((start, end))
}
}
pub fn encode_page(
out: &mut [u8],
h: &PageHeader,
entries: &[RawEntry],
) -> Result<usize, MetaError> {
let count = u16::try_from(entries.len()).map_err(|_| MetaError::Length)?;
if count != h.count {
return Err(MetaError::Field("count"));
}
let mut w = Writer::new(out);
w.u32(h.page_index)?;
w.u32(h.next_seq)?;
w.u16(count)?;
w.zeros(14)?;
for e in entries {
e.write(&mut w)?;
}
Ok(w.position())
}
#[derive(Debug, Clone, Copy)]
pub struct Page<'a> {
pub header: PageHeader,
entries: &'a [u8],
}
impl<'a> Page<'a> {
pub fn entries(&self) -> impl Iterator<Item = RawEntry> + 'a {
self.entries.chunks_exact(ENTRY2_LEN).filter_map(|c| {
RawEntry::read(&mut Reader::new(c)).ok()
})
}
}
pub fn decode_page(bytes: &[u8], page_index: u32, max_entries: u16) -> Result<Page<'_>, MetaError> {
let mut r = Reader::new(bytes);
let header = PageHeader {
page_index: r.u32()?,
next_seq: r.u32()?,
count: r.u16()?,
};
if r.bytes(14)?.iter().any(|&b| b != 0) {
return Err(MetaError::Field("reserved"));
}
if header.page_index != page_index {
return Err(MetaError::Field("page_index"));
}
if header.count > max_entries || u32::from(header.count) > header.next_seq {
return Err(MetaError::Field("count"));
}
let len = usize::from(header.count) * ENTRY2_LEN;
if bytes.len() != PAGE_HEADER_LEN + len {
return Err(MetaError::Length);
}
let entries = &bytes[PAGE_HEADER_LEN..];
let page = Page { header, entries };
let seq_at = |c: &[u8]| u32::from_le_bytes([c[0], c[1], c[2], c[3]]);
let chunks = || entries.chunks_exact(ENTRY2_LEN);
for (i, c) in chunks().enumerate() {
let seq = seq_at(c);
if seq >= header.next_seq {
return Err(MetaError::Field("seq"));
}
if c[38] != 0 || c[39] != 0 {
return Err(MetaError::Field("reserved"));
}
if chunks().skip(i + 1).any(|d| seq_at(d) == seq) {
return Err(MetaError::Duplicate);
}
}
Ok(page)
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct RegionHeader2 {
pub region_id: u64,
pub kind: RegionKind,
pub state: RegionState,
pub fill: FillPattern,
pub flags: u8,
pub compat_flags: u8,
pub log2_block: u8,
pub extent_count: u16,
pub region_generation: u64,
pub fill_key: [u8; 16],
pub object_len: u32,
}
pub type Extent = (u64, u64);
pub fn encode_region_header(
out: &mut [u8],
h: &RegionHeader2,
extents: &[Extent],
object: &[u8],
) -> Result<usize, MetaError> {
let slot = h.kind == RegionKind::Slot;
if usize::from(h.extent_count) != extents.len() || (slot && !extents.is_empty()) {
return Err(MetaError::Field("extent_count"));
}
if h.object_len as usize != object.len() || (!slot && !object.is_empty()) {
return Err(MetaError::Field("object_len"));
}
let mut w = Writer::new(out);
w.u64(h.region_id)?;
w.u8(h.kind.to_u8())?;
w.u8(h.state.to_u8())?;
w.u8(h.fill.to_u8())?;
w.u8(h.flags)?;
w.u8(h.compat_flags)?;
w.u8(h.log2_block)?;
w.u16(h.extent_count)?;
w.u64(h.region_generation)?;
w.bytes(&h.fill_key)?;
w.u32(h.object_len)?;
w.zeros(20)?;
for &(off, len) in extents {
w.u64(off)?;
w.u64(len)?;
}
w.bytes(object)?;
Ok(w.position())
}
#[derive(Debug, Clone, Copy)]
pub struct RegionHeaderView<'a> {
pub header: RegionHeader2,
tail: &'a [u8],
}
impl<'a> RegionHeaderView<'a> {
pub fn extents(&self) -> impl Iterator<Item = Extent> + 'a {
let n = usize::from(self.header.extent_count) * EXTENT_LEN;
self.tail
.get(..n)
.unwrap_or(&[])
.chunks_exact(EXTENT_LEN)
.map(|c| {
let mut a = [0u8; 8];
let mut b = [0u8; 8];
a.copy_from_slice(&c[..8]);
b.copy_from_slice(&c[8..]);
(u64::from_le_bytes(a), u64::from_le_bytes(b))
})
}
#[must_use]
pub fn object(&self) -> &'a [u8] {
if self.header.kind == RegionKind::Slot {
self.tail
} else {
&[]
}
}
}
pub fn decode_region_header(
bytes: &[u8],
log2_block: u8,
file_len: u64,
) -> Result<RegionHeaderView<'_>, MetaError> {
if !LOG2_RANGE.contains(&log2_block) {
return Err(MetaError::Field("log2_block"));
}
let mut r = Reader::new(bytes);
let region_id = r.u64()?;
let (kind, state, fill, flags) = (r.u8()?, r.u8()?, r.u8()?, r.u8()?);
if flags & !KNOWN_FLAGS != 0 {
return Err(MetaError::Field("flags"));
}
let kind = RegionKind::from_u8(kind)?;
let state = RegionState::from_u8(state)?;
let fill = FillPattern::from_u8(fill)?;
let compat_flags = r.u8()?;
let log2 = r.u8()?;
let extent_count = r.u16()?;
let region_generation = r.u64()?;
let fill_key = r.array::<16>()?;
let object_len = r.u32()?;
if r.bytes(20)?.iter().any(|&b| b != 0) {
return Err(MetaError::Field("reserved"));
}
if !(log2 == log2_block || (log2 == 9 && kind == RegionKind::Append)) {
return Err(MetaError::Field("log2_block"));
}
if region_generation == 0 {
return Err(MetaError::Field("region_generation"));
}
if fill == FillPattern::Zeros && fill_key != [0; 16] {
return Err(MetaError::Field("fill_key"));
}
let tail = &bytes[REGION_HEADER2_LEN.min(bytes.len())..];
if kind == RegionKind::Slot {
if extent_count != 0 {
return Err(MetaError::Field("extent_count"));
}
if tail.len() != object_len as usize || tail.len() > max_object(log2_block) {
return Err(MetaError::Length);
}
} else {
if object_len != 0
|| extent_count == 0
|| usize::from(extent_count) > max_extents(log2_block)
{
return Err(MetaError::Field("extent_count"));
}
if tail.len() != usize::from(extent_count) * EXTENT_LEN {
return Err(MetaError::Length);
}
}
let view = RegionHeaderView {
header: RegionHeader2 {
region_id,
kind,
state,
fill,
flags,
compat_flags,
log2_block: log2,
extent_count,
region_generation,
fill_key,
object_len,
},
tail,
};
let block = 1u64 << log2_block;
for (off, len) in view.extents() {
if len == 0 || off % block != 0 || len % block != 0 {
return Err(MetaError::Unaligned);
}
match off.checked_add(len) {
Some(end) if end <= file_len => {}
_ => return Err(MetaError::Field("extent")),
}
}
Ok(view)
}