use core::fmt;
use crate::codec::{CodecError, Reader, Writer};
use crate::crc32c::crc32c;
use crate::meta::{FillPattern, NAME_MAX, RegionKind, RegionName};
pub const MAGIC: [u8; 8] = *b"SIOXINFO";
pub const VERSION: u16 = 1;
pub const SPAN: u64 = 1 << 20;
pub const HEADER_LEN: usize = 64;
pub const RECORD_LEN: usize = 128;
pub const VERIFIED_LEN: usize = NAME_MAX + 8;
pub const MAX_LEN: u64 = 1 << 30;
const FLAG_WRITABLE: u16 = 1;
const R_CAPPED: u16 = 1;
const R_DURABLE: u16 = 1 << 1;
const R_FULL_COPY: u16 = 1 << 2;
const R_SUPERSEDED: u16 = 1 << 3;
const R_OBJECT: u16 = 1 << 4;
const R_KNOWN: u16 = R_CAPPED | R_DURABLE | R_FULL_COPY | R_SUPERSEDED | R_OBJECT;
const LOG2_MIN: u8 = 9;
const LOG2_MAX: u8 = 16;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum InfoError {
Truncated,
Length,
Checksum,
Magic,
Version,
Field(&'static str),
Buffer,
}
impl fmt::Display for InfoError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Truncated => f.write_str("export record truncated"),
Self::Length => f.write_str("export record of the wrong length"),
Self::Checksum => f.write_str("export record checksum mismatch"),
Self::Magic => f.write_str("not an export record"),
Self::Version => f.write_str("unsupported export record version"),
Self::Field(name) => write!(f, "export record field out of range: {name}"),
Self::Buffer => f.write_str("output buffer too short for the export record"),
}
}
}
impl std::error::Error for InfoError {}
impl From<CodecError> for InfoError {
fn from(e: CodecError) -> Self {
match e {
CodecError::Truncated => Self::Truncated,
CodecError::Overflow => Self::Buffer,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct InfoHeader {
pub writable: bool,
pub block_log2: u8,
pub region_count: u32,
pub lend: u32,
pub total: u64,
pub omitted_count: u32,
pub lost_count: u32,
pub stale_count: u32,
pub verified_count: u32,
}
impl InfoHeader {
#[must_use]
pub fn encode(&self) -> [u8; HEADER_LEN] {
let mut out = [0u8; HEADER_LEN];
let mut w = Writer::new(&mut out);
let _done: Result<(), CodecError> = (|| {
w.bytes(&MAGIC)?;
w.u16(VERSION)?;
w.u16(if self.writable { FLAG_WRITABLE } else { 0 })?;
w.u8(self.block_log2)?;
w.zeros(3)?;
w.u32(self.region_count)?;
w.u32(self.lend)?;
w.u64(self.total)?;
w.u32(self.omitted_count)?;
w.u32(self.lost_count)?;
w.u32(self.stale_count)?;
w.u32(self.verified_count)?;
w.zeros(16)
})();
out
}
pub fn decode(bytes: &[u8]) -> Result<Self, InfoError> {
let mut r = Reader::new(bytes);
if r.array::<8>()? != MAGIC {
return Err(InfoError::Magic);
}
if r.u16()? != VERSION {
return Err(InfoError::Version);
}
let flags = r.u16()?;
if flags & !FLAG_WRITABLE != 0 {
return Err(InfoError::Field("flags"));
}
let block_log2 = r.u8()?;
check_log2(block_log2)?;
if r.array::<3>()? != [0; 3] {
return Err(InfoError::Field("reserved"));
}
let h = Self {
writable: flags & FLAG_WRITABLE != 0,
block_log2,
region_count: r.u32()?,
lend: r.u32()?,
total: r.u64()?,
omitted_count: r.u32()?,
lost_count: r.u32()?,
stale_count: r.u32()?,
verified_count: r.u32()?,
};
if r.array::<16>()? != [0; 16] {
return Err(InfoError::Field("reserved"));
}
Ok(h)
}
}
fn check_log2(log2: u8) -> Result<(), InfoError> {
if (LOG2_MIN..=LOG2_MAX).contains(&log2) {
Ok(())
} else {
Err(InfoError::Field("block_size"))
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct RegionRecord {
pub name: RegionName,
pub kind: RegionKind,
pub fill: FillPattern,
pub fill_key: [u8; 16],
pub tag: u32,
pub generation: u64,
pub cap: Option<u64>,
pub data_size: u64,
pub durable_len: Option<u64>,
pub object_len: Option<u32>,
pub stream_len: u64,
pub full_copy: bool,
pub superseded: bool,
}
impl RegionRecord {
#[must_use]
pub fn spans(&self) -> u64 {
self.stream_len.div_ceil(SPAN)
}
pub fn check(&self) -> Result<(), InfoError> {
if self.generation == 0 {
return Err(InfoError::Field("generation"));
}
if self.cap.is_some_and(|c| c < self.data_size) {
return Err(InfoError::Field("cap"));
}
let slot = self.kind == RegionKind::Slot;
if let Some(d) = self.durable_len {
if self.kind != RegionKind::Append || self.full_copy || d > self.data_size {
return Err(InfoError::Field("durable_len"));
}
}
if self.object_len.is_some() && !slot {
return Err(InfoError::Field("object_len"));
}
if self.full_copy && slot {
return Err(InfoError::Field("flags"));
}
let stream = if slot {
u64::from(self.object_len.unwrap_or(0))
} else {
self.durable_len.unwrap_or(self.data_size)
};
if self.stream_len != stream {
return Err(InfoError::Field("stream_len"));
}
Ok(())
}
#[must_use]
pub fn encode(&self) -> [u8; RECORD_LEN] {
let mut out = [0u8; RECORD_LEN];
let mut flags = 0u16;
if self.cap.is_some() {
flags |= R_CAPPED;
}
if self.durable_len.is_some() {
flags |= R_DURABLE;
}
if self.full_copy {
flags |= R_FULL_COPY;
}
if self.superseded {
flags |= R_SUPERSEDED;
}
if self.object_len.is_some() {
flags |= R_OBJECT;
}
let mut w = Writer::new(&mut out);
let _done: Result<(), CodecError> = (|| {
w.bytes(&self.name.as_padded())?;
w.u8(self.kind.to_u8())?;
w.u8(self.fill.to_u8())?;
w.u16(flags)?;
w.u32(self.tag)?;
w.u64(self.generation)?;
w.u64(self.cap.unwrap_or(0))?;
w.bytes(&self.fill_key)?;
w.u64(self.data_size)?;
w.u64(self.durable_len.unwrap_or(0))?;
w.u32(self.object_len.unwrap_or(0))?;
w.zeros(4)?;
w.u64(self.stream_len)?;
w.zeros(32)
})();
out
}
pub fn decode(bytes: &[u8]) -> Result<Self, InfoError> {
if bytes.len() != RECORD_LEN {
return Err(InfoError::Length);
}
let mut r = Reader::new(bytes);
let name = RegionName::from_padded(r.array::<NAME_MAX>()?)
.map_err(|_| InfoError::Field("name"))?;
let kind = RegionKind::from_u8(r.u8()?).map_err(|_| InfoError::Field("kind"))?;
let fill = FillPattern::from_u8(r.u8()?).map_err(|_| InfoError::Field("fill"))?;
let flags = r.u16()?;
if flags & !R_KNOWN != 0 {
return Err(InfoError::Field("flags"));
}
let tag = r.u32()?;
let generation = r.u64()?;
let cap = r.u64()?;
let fill_key = r.array::<16>()?;
let data_size = r.u64()?;
let durable = r.u64()?;
let object_len = r.u32()?;
if r.u32()? != 0 {
return Err(InfoError::Field("reserved"));
}
let stream_len = r.u64()?;
if r.array::<32>()? != [0; 32] {
return Err(InfoError::Field("reserved"));
}
if flags & R_CAPPED == 0 && cap != 0 {
return Err(InfoError::Field("cap"));
}
if flags & R_DURABLE == 0 && durable != 0 {
return Err(InfoError::Field("durable_len"));
}
if flags & R_OBJECT == 0 && object_len != 0 {
return Err(InfoError::Field("object_len"));
}
let rec = Self {
name,
kind,
fill,
fill_key,
tag,
generation,
cap: (flags & R_CAPPED != 0).then_some(cap),
data_size,
durable_len: (flags & R_DURABLE != 0).then_some(durable),
object_len: (flags & R_OBJECT != 0).then_some(object_len),
stream_len,
full_copy: flags & R_FULL_COPY != 0,
superseded: flags & R_SUPERSEDED != 0,
};
rec.check()?;
Ok(rec)
}
}
#[derive(Debug, Clone, Copy)]
pub struct ExportInfo<'a> {
pub header: InfoHeader,
omitted: &'a [u8],
lost: &'a [u8],
stale: &'a [u8],
verified: &'a [u8],
regions: &'a [u8],
}
fn items<'a>(r: &mut Reader<'a>, n: u32, size: usize) -> Result<&'a [u8], InfoError> {
let len = (n as usize).checked_mul(size).ok_or(InfoError::Truncated)?;
Ok(r.bytes(len)?)
}
fn u64_at(b: &[u8], i: usize) -> u64 {
let mut a = [0u8; 8];
a.copy_from_slice(&b[i * 8..i * 8 + 8]);
u64::from_le_bytes(a)
}
fn u32_at(b: &[u8], i: usize) -> u32 {
let mut a = [0u8; 4];
a.copy_from_slice(&b[i * 4..i * 4 + 4]);
u32::from_le_bytes(a)
}
fn ascending<T: PartialOrd>(mut it: impl Iterator<Item = T>) -> bool {
let Some(mut prev) = it.next() else {
return true;
};
for x in it {
if x <= prev {
return false;
}
prev = x;
}
true
}
fn check_lists(
omitted: impl Iterator<Item = u64>,
lost: impl Iterator<Item = u32> + Clone,
stale: impl Iterator<Item = u32> + Clone,
verified: impl Iterator<Item = [u8; NAME_MAX]>,
) -> Result<(), InfoError> {
if !ascending(omitted) {
return Err(InfoError::Field("omitted"));
}
if !ascending(lost.clone()) {
return Err(InfoError::Field("lost"));
}
if !ascending(stale.clone()) {
return Err(InfoError::Field("stale"));
}
let mut l = lost.peekable();
for s in stale {
while l.next_if(|&x| x < s).is_some() {}
if l.peek() == Some(&s) {
return Err(InfoError::Field("stale"));
}
}
if !ascending(verified) {
return Err(InfoError::Field("verified"));
}
Ok(())
}
pub fn decode(bytes: &[u8]) -> Result<ExportInfo<'_>, InfoError> {
decode_within(bytes, MAX_LEN)
}
fn unseal(bytes: &[u8], max: u64) -> Result<&[u8], InfoError> {
if bytes.len() as u64 > max {
return Err(InfoError::Length);
}
if bytes.len() < HEADER_LEN + 4 {
return Err(InfoError::Truncated);
}
if bytes[..8] != MAGIC {
return Err(InfoError::Magic);
}
if bytes[8..10] != VERSION.to_le_bytes() {
return Err(InfoError::Version);
}
let (body, crc) = bytes.split_at(bytes.len() - 4);
if crc32c(body) != u32_at(crc, 0) {
return Err(InfoError::Checksum);
}
Ok(body)
}
fn decode_within(bytes: &[u8], max: u64) -> Result<ExportInfo<'_>, InfoError> {
let body = unseal(bytes, max)?;
let (head, used) = decode_prefix(body)?;
let all = &body[used..];
let mut r = Reader::new(all);
for _ in 0..head.header.region_count {
let rec = RegionRecord::decode(items(&mut r, 1, RECORD_LEN)?)?;
let spans = u32::try_from(rec.spans()).map_err(|_| InfoError::Truncated)?;
let _crcs = items(&mut r, spans, 4)?;
}
if r.remaining() != 0 {
return Err(InfoError::Length);
}
Ok(ExportInfo {
regions: all,
..head
})
}
fn u32s(b: &[u8]) -> impl Iterator<Item = u32> + Clone + '_ {
(0..b.len() / 4).map(move |i| u32_at(b, i))
}
fn padded(item: &[u8]) -> [u8; NAME_MAX] {
let mut raw = [0u8; NAME_MAX];
raw.copy_from_slice(&item[..NAME_MAX]);
raw
}
impl<'a> ExportInfo<'a> {
pub fn omitted(&self) -> impl Iterator<Item = u64> + 'a {
let b = self.omitted;
(0..b.len() / 8).map(move |i| u64_at(b, i))
}
pub fn lost_pages(&self) -> impl Iterator<Item = u32> + 'a {
let b = self.lost;
(0..b.len() / 4).map(move |i| u32_at(b, i))
}
pub fn stale_pages(&self) -> impl Iterator<Item = u32> + 'a {
let b = self.stale;
(0..b.len() / 4).map(move |i| u32_at(b, i))
}
pub fn verified(&self) -> impl Iterator<Item = (RegionName, u64)> + 'a {
let b = self.verified;
b.chunks_exact(VERIFIED_LEN).filter_map(|item| {
let name = RegionName::from_padded(padded(item)).ok()?;
Some((name, u64_at(&item[NAME_MAX..], 0)))
})
}
pub fn regions(&self) -> Regions<'a> {
Regions { rest: self.regions }
}
}
#[derive(Debug, Clone)]
pub struct Regions<'a> {
rest: &'a [u8],
}
#[derive(Debug, Clone, Copy)]
pub struct Spans<'a> {
b: &'a [u8],
}
impl Spans<'_> {
#[must_use]
pub fn len(&self) -> usize {
self.b.len() / 4
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.b.is_empty()
}
#[must_use]
pub fn get(&self, i: usize) -> Option<u32> {
(i < self.len()).then(|| u32_at(self.b, i))
}
}
impl<'a> Iterator for Regions<'a> {
type Item = (RegionRecord, Spans<'a>);
fn next(&mut self) -> Option<Self::Item> {
let rec = RegionRecord::decode(self.rest.get(..RECORD_LEN)?).ok()?;
let n = usize::try_from(rec.spans()).ok()?.checked_mul(4)?;
let spans = self.rest.get(RECORD_LEN..RECORD_LEN.checked_add(n)?)?;
self.rest = &self.rest[RECORD_LEN + n..];
Some((rec, Spans { b: spans }))
}
}
pub fn encode_into(info: &ExportInfo<'_>, out: &mut [u8]) -> Result<usize, CodecError> {
let mut w = Writer::new(out);
w.bytes(&info.header.encode())?;
w.bytes(info.omitted)?;
w.bytes(info.lost)?;
w.bytes(info.stale)?;
w.bytes(info.verified)?;
for (rec, spans) in info.regions() {
w.bytes(&rec.encode())?;
w.bytes(spans.b)?;
}
let n = w.position();
let crc = crc32c(&out[..n]);
let mut w = Writer::new(&mut out[n..]);
w.u32(crc)?;
Ok(n + 4)
}
pub type RegionItem<'a> = (RegionRecord, &'a [u32]);
#[must_use]
pub fn encoded_len(
omitted: usize,
lost: usize,
stale: usize,
verified: usize,
regions: &[RegionItem<'_>],
) -> Option<usize> {
let mut n = HEADER_LEN
.checked_add(omitted.checked_mul(8)?)?
.checked_add(lost.checked_add(stale)?.checked_mul(4)?)?
.checked_add(verified.checked_mul(VERIFIED_LEN)?)?
.checked_add(4)?;
for (_, spans) in regions {
n = n.checked_add(RECORD_LEN.checked_add(spans.len().checked_mul(4)?)?)?;
}
Some(n)
}
pub fn encode(
header: &InfoHeader,
omitted: &[u64],
lost: &[u32],
stale: &[u32],
verified: &[(RegionName, u64)],
regions: &[RegionItem<'_>],
out: &mut [u8],
) -> Result<usize, InfoError> {
encode_within(
header, omitted, lost, stale, verified, regions, out, MAX_LEN,
)
}
fn check_head(
header: &InfoHeader,
omitted: &[u64],
lost: &[u32],
stale: &[u32],
verified: &[(RegionName, u64)],
) -> Result<(), InfoError> {
check_log2(header.block_log2)?;
check_lists(
omitted.iter().copied(),
lost.iter().copied(),
stale.iter().copied(),
verified.iter().map(|(n, _)| n.as_padded()),
)
}
#[allow(clippy::too_many_arguments)]
fn encode_within(
header: &InfoHeader,
omitted: &[u64],
lost: &[u32],
stale: &[u32],
verified: &[(RegionName, u64)],
regions: &[RegionItem<'_>],
out: &mut [u8],
max: u64,
) -> Result<usize, InfoError> {
check_head(header, omitted, lost, stale, verified)?;
for (rec, spans) in regions {
rec.check()?;
if spans.len() as u64 != rec.spans() {
return Err(InfoError::Field("spans"));
}
}
let len = encoded_len(
omitted.len(),
lost.len(),
stale.len(),
verified.len(),
regions,
)
.ok_or(InfoError::Length)?;
if len as u64 > max {
return Err(InfoError::Length);
}
let count = |n: usize| u32::try_from(n).map_err(|_| InfoError::Length);
let h = InfoHeader {
region_count: count(regions.len())?,
omitted_count: count(omitted.len())?,
lost_count: count(lost.len())?,
stale_count: count(stale.len())?,
verified_count: count(verified.len())?,
..*header
};
let mut w = Writer::new(out);
w.bytes(&h.encode())?;
for &id in omitted {
w.u64(id)?;
}
for &p in lost.iter().chain(stale) {
w.u32(p)?;
}
for (name, len) in verified {
w.bytes(&name.as_padded())?;
w.u64(*len)?;
}
for (rec, spans) in regions {
w.bytes(&rec.encode())?;
for &c in *spans {
w.u32(c)?;
}
}
let n = w.position();
let crc = crc32c(&out[..n]);
let mut w = Writer::new(&mut out[n..]);
w.u32(crc)?;
Ok(n + 4)
}
#[must_use]
pub fn head_len(header: &InfoHeader) -> Option<usize> {
HEADER_LEN
.checked_add((header.omitted_count as usize).checked_mul(8)?)?
.checked_add(
(header.lost_count as usize)
.checked_add(header.stale_count as usize)?
.checked_mul(4)?,
)?
.checked_add((header.verified_count as usize).checked_mul(VERIFIED_LEN)?)
}
pub fn decode_prefix(bytes: &[u8]) -> Result<(ExportInfo<'_>, usize), InfoError> {
if bytes.len() < HEADER_LEN {
return Err(InfoError::Truncated);
}
let header = InfoHeader::decode(&bytes[..HEADER_LEN])?;
let mut r = Reader::new(&bytes[HEADER_LEN..]);
let omitted = items(&mut r, header.omitted_count, 8)?;
let lost = items(&mut r, header.lost_count, 4)?;
let stale = items(&mut r, header.stale_count, 4)?;
let verified = items(&mut r, header.verified_count, VERIFIED_LEN)?;
for item in verified.chunks_exact(VERIFIED_LEN) {
let _name =
RegionName::from_padded(padded(item)).map_err(|_| InfoError::Field("verified"))?;
}
check_lists(
(0..omitted.len() / 8).map(|i| u64_at(omitted, i)),
u32s(lost),
u32s(stale),
verified.chunks_exact(VERIFIED_LEN).map(padded),
)?;
let used = HEADER_LEN + r.position();
Ok((
ExportInfo {
header,
omitted,
lost,
stale,
verified,
regions: &[],
},
used,
))
}
pub fn encode_head(
header: &InfoHeader,
omitted: &[u64],
lost: &[u32],
stale: &[u32],
verified: &[(RegionName, u64)],
out: &mut [u8],
) -> Result<usize, InfoError> {
check_head(header, omitted, lost, stale, verified)?;
let count = |n: usize| u32::try_from(n).map_err(|_| InfoError::Length);
let h = InfoHeader {
omitted_count: count(omitted.len())?,
lost_count: count(lost.len())?,
stale_count: count(stale.len())?,
verified_count: count(verified.len())?,
..*header
};
let mut w = Writer::new(out);
w.bytes(&h.encode())?;
for &id in omitted {
w.u64(id)?;
}
for &p in lost.iter().chain(stale) {
w.u32(p)?;
}
for (name, len) in verified {
w.bytes(&name.as_padded())?;
w.u64(*len)?;
}
let n = w.position();
let crc = crc32c(&out[..n]);
let mut w = Writer::new(&mut out[n..]);
w.u32(crc)?;
Ok(n + 4)
}
pub fn decode_head(bytes: &[u8]) -> Result<ExportInfo<'_>, InfoError> {
let body = unseal(bytes, MAX_LEN)?;
let (info, used) = decode_prefix(body)?;
if used != body.len() {
return Err(InfoError::Length);
}
Ok(info)
}
#[cfg(test)]
mod tests {
#![allow(clippy::unwrap_used, clippy::expect_used)]
use super::*;
fn name(s: &str) -> RegionName {
RegionName::new(s).unwrap()
}
fn header() -> InfoHeader {
InfoHeader {
writable: true,
block_log2: 12,
region_count: 0,
lend: 5,
total: 123_456_789,
omitted_count: 0,
lost_count: 0,
stale_count: 0,
verified_count: 0,
}
}
fn record(n: &str, kind: RegionKind, stream_len: u64) -> RegionRecord {
RegionRecord {
name: name(n),
kind,
fill: FillPattern::KeyedV1,
fill_key: [7; 16],
tag: 42,
generation: 3,
cap: None,
data_size: stream_len,
durable_len: None,
object_len: None,
stream_len,
full_copy: false,
superseded: false,
}
}
fn regions() -> [RegionRecord; 3] {
let mut a = record("log", RegionKind::Append, 3 * SPAN + 5);
a.data_size = 4 * SPAN;
a.cap = Some(1 << 30);
a.durable_len = Some(3 * SPAN + 5);
let mut b = record("pages", RegionKind::Page, 2 * SPAN);
b.full_copy = true;
b.superseded = true;
b.fill = FillPattern::Zeros;
let mut c = record("obj", RegionKind::Slot, 6);
c.data_size = 0;
c.object_len = Some(6);
[a, b, c]
}
fn sample() -> Vec<u8> {
let [a, b, c] = regions();
let (sa, sb, sc) = ([1, 2, 3, 4], [5, 6], [7]);
let regions: [RegionItem<'_>; 3] = [(a, &sa), (b, &sb), (c, &sc)];
let verified = [(name("pages"), 77)];
let len = encoded_len(2, 1, 2, 1, ®ions).unwrap();
let mut out = vec![0u8; len];
let n = encode(
&header(),
&[9, 1 << 33],
&[3],
&[1, 2],
&verified,
®ions,
&mut out,
)
.unwrap();
assert_eq!(n, len);
out
}
fn resealed(mut b: Vec<u8>) -> Vec<u8> {
let n = b.len() - 4;
let crc = crc32c(&b[..n]).to_le_bytes();
b[n..].copy_from_slice(&crc);
b
}
fn edited(edits: &[(usize, &[u8])]) -> Option<InfoError> {
let mut x = sample();
for (off, v) in edits {
x[*off..*off + v.len()].copy_from_slice(v);
}
decode(&resealed(x)).err()
}
const OMITTED: usize = HEADER_LEN;
const LOST: usize = OMITTED + 16;
const STALE: usize = LOST + 4;
const VERIFIED: usize = STALE + 8;
const R0: usize = VERIFIED + VERIFIED_LEN;
const R1: usize = R0 + RECORD_LEN + 16;
const R2: usize = R1 + RECORD_LEN + 8;
#[test]
fn test_a_record_round_trips_exactly() {
let b = sample();
let info = decode(&b).unwrap();
assert_eq!(info.header.region_count, 3);
assert!(info.header.writable);
assert_eq!((info.header.lend, info.header.total), (5, 123_456_789));
assert_eq!(info.omitted().collect::<Vec<_>>(), [9, 1 << 33]);
assert_eq!(info.lost_pages().collect::<Vec<_>>(), [3]);
assert_eq!(info.stale_pages().collect::<Vec<_>>(), [1, 2]);
assert_eq!(info.verified().collect::<Vec<_>>(), [(name("pages"), 77)]);
let got: Vec<_> = info.regions().collect();
assert_eq!(got.len(), 3);
for (i, want) in regions().iter().enumerate() {
assert_eq!(&got[i].0, want, "region {i}");
}
let sa = got[0].1;
assert_eq!(
(0..sa.len())
.map(|i| sa.get(i).unwrap())
.collect::<Vec<_>>(),
[1, 2, 3, 4]
);
assert_eq!(sa.get(4), None);
assert_eq!((got[1].1.len(), got[2].1.len()), (2, 1));
let mut again = vec![0u8; b.len()];
assert_eq!(encode_into(&info, &mut again).unwrap(), b.len());
assert_eq!(again, b);
}
#[test]
fn test_every_flipped_bit_is_refused() {
let b = sample();
for i in 0..b.len() * 8 {
let mut x = b.clone();
x[i / 8] ^= 1 << (i % 8);
assert!(decode(&x).is_err(), "bit {i}");
}
}
#[test]
fn test_every_truncation_and_extension_is_refused() {
let b = sample();
for n in 0..b.len() {
assert!(decode(&b[..n]).is_err(), "cut at {n}");
}
let mut longer = b[..b.len() - 4].to_vec();
longer.push(0);
longer.extend_from_slice(&[0; 4]);
assert_eq!(decode(&resealed(longer)).err(), Some(InfoError::Length));
}
#[test]
fn test_a_short_sealed_body_is_truncated() {
let b = sample();
for n in 4..HEADER_LEN + 4 {
let mut x = b[..n].to_vec();
x[n - 4..].fill(0);
assert_eq!(
decode(&resealed(x)).err(),
Some(InfoError::Truncated),
"{n}"
);
}
}
#[test]
fn test_magic_and_version_are_told_before_the_checksum() {
let mut x = sample();
x[0] = b'X';
assert_eq!(decode(&x).err(), Some(InfoError::Magic));
let mut x = sample();
x[8] = 2;
assert_eq!(decode(&x).err(), Some(InfoError::Version));
let mut x = sample();
x[20] ^= 1;
assert_eq!(decode(&x).err(), Some(InfoError::Checksum));
}
#[test]
fn test_each_header_field_out_of_range_is_refused() {
assert_eq!(
edited(&[(10, &2u16.to_le_bytes())]),
Some(InfoError::Field("flags"))
);
assert_eq!(edited(&[(12, &[8])]), Some(InfoError::Field("block_size")));
assert_eq!(edited(&[(12, &[17])]), Some(InfoError::Field("block_size")));
assert_eq!(edited(&[(13, &[1])]), Some(InfoError::Field("reserved")));
assert_eq!(edited(&[(63, &[1])]), Some(InfoError::Field("reserved")));
assert_eq!(
edited(&[(16, &4u32.to_le_bytes())]),
Some(InfoError::Truncated)
);
assert_eq!(
edited(&[(32, &u32::MAX.to_le_bytes())]),
Some(InfoError::Truncated)
);
assert_eq!(
edited(&[(44, &u32::MAX.to_le_bytes())]),
Some(InfoError::Truncated)
);
assert_eq!(
edited(&[(16, &2u32.to_le_bytes())]),
Some(InfoError::Length)
);
}
#[test]
fn test_each_list_must_be_ascending() {
assert_eq!(
edited(&[(OMITTED, &(1u64 << 34).to_le_bytes())]),
Some(InfoError::Field("omitted"))
);
assert_eq!(
edited(&[(OMITTED, &(1u64 << 33).to_le_bytes())]),
Some(InfoError::Field("omitted")),
"a duplicate"
);
assert_eq!(
edited(&[(STALE, &2u32.to_le_bytes())]),
Some(InfoError::Field("stale")),
"a duplicate"
);
assert_eq!(
edited(&[(STALE + 4, &3u32.to_le_bytes())]),
Some(InfoError::Field("stale")),
"both lost and stale"
);
assert_eq!(
edited(&[(VERIFIED, &[0])]),
Some(InfoError::Field("verified"))
);
let enc = |lost: &[u32], stale: &[u32], verified: &[(RegionName, u64)]| {
let mut out = vec![0u8; 4096];
encode(&header(), &[], lost, stale, verified, &[], &mut out).err()
};
assert_eq!(enc(&[2, 1], &[], &[]), Some(InfoError::Field("lost")));
assert_eq!(enc(&[1], &[1], &[]), Some(InfoError::Field("stale")));
assert_eq!(
enc(&[], &[], &[(name("b"), 1), (name("a"), 1)]),
Some(InfoError::Field("verified"))
);
assert_eq!(enc(&[1, 3], &[2, 4], &[]), None);
}
#[test]
fn test_each_record_field_out_of_range_is_refused() {
assert_eq!(edited(&[(R0, &[0])]), Some(InfoError::Field("name")));
assert_eq!(edited(&[(R0 + 24, &[4])]), Some(InfoError::Field("kind")));
assert_eq!(edited(&[(R0 + 25, &[2])]), Some(InfoError::Field("fill")));
assert_eq!(
edited(&[(R0 + 26, &[0x20])]),
Some(InfoError::Field("flags"))
);
assert_eq!(
edited(&[(R0 + 84, &[1])]),
Some(InfoError::Field("reserved"))
);
assert_eq!(
edited(&[(R0 + 127, &[1])]),
Some(InfoError::Field("reserved"))
);
let big = (1u64 << 40).to_le_bytes();
assert_eq!(
edited(&[(R1 + 64, &big), (R1 + 88, &big)]),
Some(InfoError::Truncated)
);
}
#[test]
fn test_a_record_s_fields_agree_with_its_kind() {
let [a, b, c] = regions();
for r in [a, b, c] {
assert_eq!(r.check(), Ok(()));
assert_eq!(RegionRecord::decode(&r.encode()), Ok(r));
}
let bad = |f: &dyn Fn(&mut RegionRecord), r: RegionRecord| {
let mut r = r;
f(&mut r);
(r.check().err(), RegionRecord::decode(&r.encode()).err())
};
let both = |e: &'static str| (Some(InfoError::Field(e)), Some(InfoError::Field(e)));
assert_eq!(bad(&|r| r.generation = 0, a), both("generation"));
assert_eq!(bad(&|r| r.cap = Some(r.data_size - 1), a), both("cap"));
assert_eq!(
bad(&|r| r.durable_len = Some(r.data_size + 1), a),
both("durable_len")
);
assert_eq!(bad(&|r| r.durable_len = Some(1), b), both("durable_len"));
let page = record("p", RegionKind::Page, 10);
assert_eq!(
bad(&|r| r.durable_len = Some(10), page),
both("durable_len")
);
assert_eq!(
bad(
&|r| {
r.durable_len = Some(r.stream_len);
r.full_copy = true;
},
a
),
both("durable_len")
);
assert_eq!(bad(&|r| r.object_len = Some(1), b), both("object_len"));
assert_eq!(bad(&|r| r.object_len = Some(0), b), both("object_len"));
assert_eq!(bad(&|r| r.full_copy = true, c), both("flags"));
assert_eq!(bad(&|r| r.stream_len += 1, a), both("stream_len"));
assert_eq!(bad(&|r| r.stream_len -= 1, b), both("stream_len"));
assert_eq!(bad(&|r| r.stream_len = 5, c), both("stream_len"));
let mut u = a;
u.durable_len = None;
u.stream_len = u.data_size;
assert_eq!(u.check(), Ok(()));
}
#[test]
fn test_an_absent_field_must_be_zero() {
let rec = record("pages", RegionKind::Page, 10);
let mut b = rec.encode();
assert_eq!(RegionRecord::decode(&b).unwrap(), rec);
b[40] = 1;
assert_eq!(
RegionRecord::decode(&b).err(),
Some(InfoError::Field("cap"))
);
let mut b = rec.encode();
b[72] = 1;
assert_eq!(
RegionRecord::decode(&b).err(),
Some(InfoError::Field("durable_len"))
);
let b = rec.encode();
assert_eq!(
RegionRecord::decode(&b[..127]).err(),
Some(InfoError::Length)
);
let mut longer = b.to_vec();
longer.push(0);
assert_eq!(RegionRecord::decode(&longer).err(), Some(InfoError::Length));
}
#[test]
fn test_spans_cover_the_stream_length() {
for (len, spans) in [(0, 0), (1, 1), (SPAN, 1), (SPAN + 1, 2), (3 * SPAN, 3)] {
assert_eq!(record("x", RegionKind::Page, len).spans(), spans, "{len}");
}
let r = record("x", RegionKind::Page, SPAN + 1);
let mut out = vec![0u8; 4096];
let one: [RegionItem<'_>; 1] = [(r, &[1])];
assert_eq!(
encode(&header(), &[], &[], &[], &[], &one, &mut out).err(),
Some(InfoError::Field("spans"))
);
}
#[test]
fn test_the_encoder_refuses_what_the_decoder_would() {
let mut out = vec![0u8; 4096];
let h = InfoHeader {
block_log2: 20,
..header()
};
assert_eq!(
encode(&h, &[], &[], &[], &[], &[], &mut out).err(),
Some(InfoError::Field("block_size"))
);
let mut r = record("x", RegionKind::Page, 10);
r.generation = 0;
let one: [RegionItem<'_>; 1] = [(r, &[1])];
assert_eq!(
encode(&header(), &[], &[], &[], &[], &one, &mut out).err(),
Some(InfoError::Field("generation"))
);
let len = encoded_len(0, 0, 0, 0, &[]).unwrap() as u64;
assert!(encode_within(&header(), &[], &[], &[], &[], &[], &mut out, len).is_ok());
assert_eq!(
encode_within(&header(), &[], &[], &[], &[], &[], &mut out, len - 1).err(),
Some(InfoError::Length)
);
let mut short = vec![0u8; HEADER_LEN];
assert_eq!(
encode(&header(), &[], &[], &[], &[], &[], &mut short).err(),
Some(InfoError::Buffer)
);
}
#[test]
fn test_a_record_over_the_limit_is_refused_unread() {
let b = sample();
let n = b.len() as u64;
assert!(decode_within(&b, n).is_ok());
assert_eq!(decode_within(&b, n - 1).err(), Some(InfoError::Length));
let mut bad = b.clone();
bad[0] ^= 1;
assert_eq!(decode_within(&bad, n - 1).err(), Some(InfoError::Length));
}
#[test]
fn test_the_fuzz_seeds_are_valid_records() {
let fuzz = concat!(env!("CARGO_MANIFEST_DIR"), "/../../fuzz");
if !std::path::Path::new(fuzz).join("seeds.py").exists() {
return;
}
for (seed, regions) in [("three-regions", 3), ("empty", 0), ("slots", 2)] {
let path = format!("{fuzz}/corpus/export_info/{seed}");
let b = std::fs::read(&path).unwrap_or_else(|e| panic!("{path}: {e}"));
let info = decode(&b).unwrap_or_else(|e| panic!("{seed}: {e}"));
assert_eq!(info.regions().count(), regions, "{seed}");
let mut again = vec![0u8; b.len()];
assert_eq!(encode_into(&info, &mut again).unwrap(), b.len());
assert_eq!(again, b, "{seed}");
}
}
#[test]
fn test_a_short_buffer_is_an_overflow() {
let b = sample();
let info = decode(&b).unwrap();
let mut short = vec![0u8; b.len() - 1];
assert_eq!(
encode_into(&info, &mut short).err(),
Some(CodecError::Overflow)
);
}
#[test]
fn test_r2_is_the_slot_record() {
let b = sample();
assert_eq!(
RegionRecord::decode(&b[R2..R2 + RECORD_LEN]).unwrap(),
regions()[2]
);
}
#[test]
fn test_a_head_alone_round_trips_and_is_checked() {
let mut h = header();
h.region_count = 7;
let verified = [(name("a"), 4096u64), (name("b"), 8192)];
let mut out = vec![0u8; 512];
let n = encode_head(&h, &[3, 9], &[1], &[2, 5], &verified, &mut out).unwrap();
assert_eq!(
Some(n - 4),
head_len(&decode_head(&out[..n]).unwrap().header)
);
let info = decode_head(&out[..n]).unwrap();
assert_eq!(info.header.region_count, 7);
assert_eq!(info.omitted().collect::<Vec<_>>(), [3, 9]);
assert_eq!(info.lost_pages().collect::<Vec<_>>(), [1]);
assert_eq!(info.stale_pages().collect::<Vec<_>>(), [2, 5]);
assert_eq!(info.verified().collect::<Vec<_>>(), verified);
assert_eq!(info.regions().count(), 0);
let mut bad = out[..n].to_vec();
bad[HEADER_LEN] ^= 1;
assert_eq!(decode_head(&bad).unwrap_err(), InfoError::Checksum);
assert_eq!(
decode_head(&out[..HEADER_LEN]).unwrap_err(),
InfoError::Truncated
);
let mut long = out[..n - 4].to_vec();
long.extend_from_slice(&[0; 4]);
let crc = crc32c(&long);
long.extend_from_slice(&crc.to_le_bytes());
assert_eq!(decode_head(&long).unwrap_err(), InfoError::Length);
assert_eq!(
encode_head(&h, &[9, 3], &[], &[], &[], &mut [0u8; 512]).unwrap_err(),
InfoError::Field("omitted")
);
assert_eq!(
decode_prefix(&out[..n - 8]).unwrap_err(),
InfoError::Truncated
);
let (p, used) = decode_prefix(&out[..n]).unwrap();
assert_eq!(used, n - 4);
assert_eq!(p.header, info.header);
}
#[test]
fn test_a_slot_s_committed_object_is_flagged() {
for obj in [None, Some(0u32), Some(6)] {
let mut r = record("s", RegionKind::Slot, u64::from(obj.unwrap_or(0)));
r.data_size = 0;
r.object_len = obj;
let b = r.encode();
assert_eq!(RegionRecord::decode(&b).unwrap(), r, "{obj:?}");
assert_eq!(b[26] & (1 << 4) != 0, obj.is_some(), "{obj:?}");
}
let mut r = record("s", RegionKind::Slot, 6);
r.data_size = 0;
r.object_len = Some(6);
let mut b = r.encode();
b[26] &= !(1 << 4);
assert_eq!(
RegionRecord::decode(&b).unwrap_err(),
InfoError::Field("object_len")
);
}
}