mod pages;
mod record;
pub use pages::Pages;
pub use record::{Bytes, Record};
use alloc::vec::Vec;
pub const PAGE_SIZE: u64 = 65_536;
const HEADER: usize = 128;
pub(crate) const MAX_REGIONS: usize = 4;
pub trait Memory: Clone {
fn size(&self) -> u64;
fn grow(&self, pages: u64) -> Option<u64>;
fn read(&self, offset: u64, destination: &mut [u8]);
fn write(&self, offset: u64, source: &[u8]);
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Error {
NotFresh,
Layout,
Bounds,
Growth,
Claimed,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Specification {
pub id: u64,
pub bytes: u64,
}
pub struct Store<M: Memory> {
memory: M,
regions: Vec<(Specification, u64, bool)>,
fresh: bool,
}
pub(crate) fn layout(specs: &[Specification]) -> Result<([u8; HEADER], u64), Error> {
if specs.is_empty() || specs.len() > MAX_REGIONS {
return Err(Error::Bounds);
}
let mut header = [0; HEADER];
header[..8].copy_from_slice(b"ICKPT001");
header[8..16].copy_from_slice(&(specs.len() as u64).to_le_bytes());
let mut end = HEADER as u64;
let mut prior = 0;
for (index, spec) in specs.iter().enumerate() {
if spec.id <= prior || spec.bytes < 16 {
return Err(Error::Bounds);
}
prior = spec.id;
let start = 16 + index * 24;
header[start..start + 8].copy_from_slice(&spec.id.to_le_bytes());
header[start + 8..start + 16].copy_from_slice(&end.to_le_bytes());
header[start + 16..start + 24].copy_from_slice(&spec.bytes.to_le_bytes());
end = end.checked_add(spec.bytes).ok_or(Error::Bounds)?;
}
if end > u64::MAX / PAGE_SIZE * PAGE_SIZE {
return Err(Error::Bounds);
}
Ok((header, end))
}
impl<M: Memory> Store<M> {
pub fn create(memory: M, specs: &[Specification]) -> Result<Self, Error> {
let (header, end) = layout(specs)?;
if memory.size() != 0 {
return Err(Error::NotFresh);
}
let pages = end.div_ceil(PAGE_SIZE);
if memory.grow(pages) != Some(0) || memory.size() != pages {
return Err(Error::Growth);
}
memory.write(0, &header);
Ok(Self::admitted(memory, specs, true))
}
pub fn open(memory: M, specs: &[Specification]) -> Result<Self, Error> {
let (expected, end) = layout(specs)?;
if memory.size() != end.div_ceil(PAGE_SIZE) {
return Err(Error::Layout);
}
let mut actual = [0; HEADER];
memory.read(0, &mut actual);
if actual != expected {
return Err(Error::Layout);
}
Ok(Self::admitted(memory, specs, false))
}
fn admitted(memory: M, specs: &[Specification], fresh: bool) -> Self {
let mut offset = HEADER as u64;
let regions = specs
.iter()
.map(|spec| {
let start = offset;
offset += spec.bytes; (*spec, start, false)
})
.collect();
Self {
memory,
regions,
fresh,
}
}
pub fn take(&mut self, id: u64) -> Result<Region<M>, Error> {
let (spec, offset, claimed) = self
.regions
.iter_mut()
.find(|(spec, _, _)| spec.id == id)
.ok_or(Error::Bounds)?;
if *claimed {
return Err(Error::Claimed);
}
*claimed = true;
Ok(Region {
memory: self.memory.clone(),
offset: *offset,
bytes: spec.bytes,
fresh: self.fresh,
})
}
}
pub struct Region<M: Memory> {
memory: M,
offset: u64,
bytes: u64,
fresh: bool,
}
impl<M: Memory> Region<M> {
fn fits(&self, offset: u64, length: u64) -> Result<(), Error> {
if offset
.checked_add(length)
.is_none_or(|end| end > self.bytes)
{
return Err(Error::Bounds);
}
Ok(())
}
fn read(&self, offset: u64, destination: &mut [u8]) {
self.memory.read(self.offset + offset, destination);
}
fn write(&self, offset: u64, source: &[u8]) {
self.memory.write(self.offset + offset, source);
}
fn header(&self, magic: &[u8; 8]) -> Result<u64, Error> {
let mut header = [0; 16];
self.read(0, &mut header);
if header[..8] != *magic {
return Err(Error::Layout);
}
Ok(u64::from_le_bytes(
header[8..].try_into().map_err(|_| Error::Layout)?,
))
}
fn initialize(&self, magic: &[u8; 8], length: u64) -> Result<(), Error> {
if !self.fresh {
return Err(Error::NotFresh);
}
let mut existing = [0; 16];
self.read(0, &mut existing);
if existing != [0; 16] {
return Err(Error::NotFresh);
}
let mut header = [0; 16];
header[..8].copy_from_slice(magic);
header[8..].copy_from_slice(&length.to_le_bytes());
self.write(0, &header);
Ok(())
}
}
#[cfg(test)]
mod tests;