use std::cell::RefCell;
use std::collections::BTreeSet;
use std::fs::{self, File, OpenOptions};
use std::io::{Read, Seek, SeekFrom, Write};
use std::path::{Path, PathBuf};
use std::sync::Arc;
use memmap2::Mmap;
use crate::core::errors::{PvError, Result};
use crate::core::types::{
FileHeader, CHUNK_CAP_BYTES, FILE_HEADER_SIZE, FORMAT_VERSION_BASE, PAGE_CHECKSUM_OFFSET,
PAGE_SIZE,
};
pub const PAGES_PER_CHUNK: u64 = CHUNK_CAP_BYTES / PAGE_SIZE as u64;
pub type PageBuf = Box<[u8; PAGE_SIZE]>;
pub fn page_checksum(page: &[u8; PAGE_SIZE]) -> u32 {
let mut hasher = blake3::Hasher::new();
hasher.update(&page[..PAGE_CHECKSUM_OFFSET]);
hasher.update(&page[PAGE_CHECKSUM_OFFSET + 4..]);
let bytes = hasher.finalize();
let bytes = bytes.as_bytes();
let value = u32::from_le_bytes([bytes[0], bytes[1], bytes[2], bytes[3]]);
if value == 0 {
1
} else {
value
}
}
pub fn stamp_page_checksum(page: &mut [u8; PAGE_SIZE]) {
let checksum = page_checksum(page);
page[PAGE_CHECKSUM_OFFSET..PAGE_CHECKSUM_OFFSET + 4].copy_from_slice(&checksum.to_le_bytes());
}
pub fn verify_page_checksum(id: u64, page: &[u8; PAGE_SIZE]) -> Result<()> {
let stored = u32::from_le_bytes(
page[PAGE_CHECKSUM_OFFSET..PAGE_CHECKSUM_OFFSET + 4]
.try_into()
.expect("4-byte checksum field"),
);
if stored == 0 {
return Ok(());
}
let computed = page_checksum(page);
if stored != computed {
return Err(PvError::Corruption(format!(
"page {id} checksum mismatch (stored {stored:#010x}, computed {computed:#010x})"
)));
}
Ok(())
}
pub struct DevStore {
root: PathBuf,
page_count: u64,
write_handle: RefCell<Option<(u64, File)>>,
dirty_chunks: RefCell<BTreeSet<u64>>,
journal: RefCell<Option<crate::journal::Journal>>,
}
impl DevStore {
pub fn create(root: impl Into<PathBuf>) -> Result<Self> {
let root = root.into();
fs::create_dir_all(root.join("chunks"))?;
Ok(Self {
root,
page_count: 0,
write_handle: RefCell::new(None),
dirty_chunks: RefCell::new(BTreeSet::new()),
journal: RefCell::new(None),
})
}
pub fn open(root: impl Into<PathBuf>, page_count: u64) -> Result<Self> {
let root = root.into();
fs::create_dir_all(root.join("chunks"))?;
Ok(Self {
root,
page_count,
write_handle: RefCell::new(None),
dirty_chunks: RefCell::new(BTreeSet::new()),
journal: RefCell::new(None),
})
}
pub fn page_count(&self) -> u64 {
self.page_count
}
pub(crate) fn begin_journal(&self, options: crate::CommitLogOptions) -> Result<()> {
*self.journal.borrow_mut() = Some(
crate::journal::Journal::begin(&self.root, options).map_err(|error| {
if self
.root
.join(crate::COMMIT_LOG_DIR)
.join("active")
.exists()
{
PvError::TransactionOutcomeUnknown(format!(
"journal preparation requires recovery: {error}"
))
} else {
error
}
})?,
);
Ok(())
}
pub(crate) fn commit_journal(&self) -> Result<()> {
let mut journal = self.journal.borrow_mut();
journal
.as_mut()
.ok_or_else(|| PvError::Transaction("no active page journal".into()))?
.commit()?;
journal.take();
Ok(())
}
pub(crate) fn journal_sequence(&self) -> Option<u64> {
self.journal
.borrow()
.as_ref()
.map(crate::journal::Journal::sequence)
}
pub fn set_page_count(&mut self, n: u64) {
self.page_count = n;
}
fn chunk_path(&self, chunk_ix: u64) -> PathBuf {
self.root
.join("chunks")
.join(format!("chunk_{chunk_ix:05}.pvd"))
}
pub fn alloc_page(&mut self) -> u64 {
let id = self.page_count;
self.page_count += 1;
id
}
fn with_chunk_write<R>(
&self,
chunk_ix: u64,
f: impl FnOnce(&mut File) -> Result<R>,
) -> Result<R> {
self.dirty_chunks.borrow_mut().insert(chunk_ix);
let mut slot = self.write_handle.borrow_mut();
let needs_open = slot.as_ref().map(|(ix, _)| *ix) != Some(chunk_ix);
if needs_open {
let file = OpenOptions::new()
.read(true)
.write(true)
.create(true)
.truncate(false) .open(self.chunk_path(chunk_ix))?;
*slot = Some((chunk_ix, file));
}
let (_, file) = slot.as_mut().expect("handle present");
f(file)
}
pub fn write_page(&self, id: u64, page: &[u8; PAGE_SIZE]) -> Result<()> {
if let Some(journal) = self.journal.borrow_mut().as_mut() {
journal.before_write(id)?;
}
let within = (id % PAGES_PER_CHUNK) * PAGE_SIZE as u64;
self.with_chunk_write(id / PAGES_PER_CHUNK, |file| {
file.seek(SeekFrom::Start(within))?;
file.write_all(page)?;
Ok(())
})
}
pub fn write_pages_from(&self, start_id: u64, pages: &[&PageBuf]) -> Result<()> {
if self.journal.borrow().is_some() {
for (offset, page) in pages.iter().enumerate() {
self.write_page(start_id + offset as u64, page)?;
}
return Ok(());
}
let end = start_id + pages.len() as u64;
let mut id = start_id;
let mut idx = 0usize;
while id < end {
let chunk_ix = id / PAGES_PER_CHUNK;
let chunk_start = chunk_ix * PAGES_PER_CHUNK;
let chunk_page_end = ((chunk_ix + 1) * PAGES_PER_CHUNK).min(end);
let count = (chunk_page_end - id) as usize;
let mut batch = Vec::with_capacity(count * PAGE_SIZE);
for page in &pages[idx..idx + count] {
batch.extend_from_slice(&page[..]);
}
self.with_chunk_write(chunk_ix, |file| {
file.seek(SeekFrom::Start((id - chunk_start) * PAGE_SIZE as u64))?;
file.write_all(&batch)?;
Ok(())
})?;
idx += count;
id = chunk_page_end;
}
Ok(())
}
pub fn sync_data(&self) -> Result<()> {
let dirty: Vec<u64> = self.dirty_chunks.borrow().iter().copied().collect();
for chunk_ix in dirty {
let cached = self.write_handle.borrow().as_ref().map(|(ix, _)| *ix) == Some(chunk_ix);
if cached {
if let Some((_, file)) = self.write_handle.borrow().as_ref() {
file.sync_all()?;
}
} else {
OpenOptions::new()
.read(true)
.write(true)
.open(self.chunk_path(chunk_ix))?
.sync_all()?;
}
}
self.dirty_chunks.borrow_mut().clear();
Ok(())
}
pub fn read_page(&self, id: u64) -> Result<PageBuf> {
if id >= self.page_count {
return Err(PvError::PageFault { page_id: id });
}
let within = (id % PAGES_PER_CHUNK) * PAGE_SIZE as u64;
let path = self.chunk_path(id / PAGES_PER_CHUNK);
let mut file = File::open(&path)?;
file.seek(SeekFrom::Start(within))?;
let mut buf: PageBuf = Box::new([0u8; PAGE_SIZE]);
file.read_exact(&mut buf[..])?;
Ok(buf)
}
pub fn read_all_pages(&self) -> Result<Vec<PageBuf>> {
let capacity = usize::try_from(self.page_count).map_err(|_| {
PvError::Corruption("workspace page count is too large for this platform".into())
})?;
let mut out = Vec::with_capacity(capacity);
let mut id = 0u64;
while id < self.page_count {
let chunk_ix = id / PAGES_PER_CHUNK;
let chunk_start = chunk_ix * PAGES_PER_CHUNK;
let chunk_end = ((chunk_ix + 1) * PAGES_PER_CHUNK).min(self.page_count);
let path = self.chunk_path(chunk_ix);
let mut file = File::open(&path)?;
file.seek(SeekFrom::Start((id - chunk_start) * PAGE_SIZE as u64))?;
for _ in id..chunk_end {
let mut buf: PageBuf = Box::new([0u8; PAGE_SIZE]);
file.read_exact(&mut buf[..])?;
out.push(buf);
}
id = chunk_end;
}
Ok(out)
}
}
pub struct Monolith {
mmap: Arc<Mmap>,
header: FileHeader,
cas_offset: usize,
manifest_offset: usize,
_snapshot_file: File,
}
impl Monolith {
pub fn open(path: impl AsRef<Path>) -> Result<Self> {
let source = File::open(path)?;
let source_len = source.metadata()?.len();
if source_len < FILE_HEADER_SIZE as u64 {
return Err(PvError::Corruption(
"monolith smaller than file header".into(),
));
}
usize::try_from(source_len)
.map_err(|_| PvError::Corruption("monolith is too large for this platform".into()))?;
let mut snapshot_file = tempfile::tempfile()?;
let copied = std::io::copy(&mut source.take(source_len), &mut snapshot_file)?;
if copied != source_len {
return Err(PvError::Corruption(
"monolith changed length while it was being opened".into(),
));
}
snapshot_file.flush()?;
snapshot_file.seek(SeekFrom::Start(0))?;
let mmap = unsafe { Mmap::map(&snapshot_file)? };
let header = FileHeader::decode(&mmap[..FILE_HEADER_SIZE])?;
let cas_offset = usize::try_from(header.cas_offset)
.map_err(|_| PvError::Corruption("monolith CAS offset is too large".into()))?;
let manifest_offset = usize::try_from(header.manifest_offset)
.map_err(|_| PvError::Corruption("monolith manifest offset is too large".into()))?;
if cas_offset < FILE_HEADER_SIZE
|| manifest_offset < cas_offset
|| manifest_offset > mmap.len()
|| (cas_offset - FILE_HEADER_SIZE) % PAGE_SIZE != 0
{
return Err(PvError::Corruption(
"monolith offsets are inconsistent".into(),
));
}
Ok(Self {
mmap: Arc::new(mmap),
header,
cas_offset,
manifest_offset,
_snapshot_file: snapshot_file,
})
}
pub fn page_count(&self) -> u64 {
((self.cas_offset - FILE_HEADER_SIZE) / PAGE_SIZE) as u64
}
pub fn format_version(&self) -> u16 {
self.header.format_version
}
pub fn read_page(&self, id: u64) -> Result<PageBuf> {
if id >= self.page_count() {
return Err(PvError::PageFault { page_id: id });
}
let start = FILE_HEADER_SIZE + id as usize * PAGE_SIZE;
let mut buf: PageBuf = Box::new([0u8; PAGE_SIZE]);
buf.copy_from_slice(&self.mmap[start..start + PAGE_SIZE]);
Ok(buf)
}
pub fn cas_offset(&self) -> usize {
self.cas_offset
}
pub fn manifest_offset(&self) -> usize {
self.manifest_offset
}
pub fn manifest_bytes(&self) -> &[u8] {
&self.mmap[self.manifest_offset..]
}
pub fn mmap(&self) -> Arc<Mmap> {
self.mmap.clone()
}
}
#[derive(Default)]
pub struct MemStore {
pages: RefCell<Vec<PageBuf>>,
}
impl MemStore {
pub fn new() -> Self {
Self::default()
}
pub fn page_count(&self) -> u64 {
self.pages.borrow().len() as u64
}
pub fn alloc_page(&self) -> u64 {
let mut pages = self.pages.borrow_mut();
let id = pages.len() as u64;
pages.push(Box::new([0u8; PAGE_SIZE]));
id
}
pub fn write_page(&self, id: u64, page: &[u8; PAGE_SIZE]) -> Result<()> {
let index = usize::try_from(id).map_err(|_| PvError::PageFault { page_id: id })?;
let mut pages = self.pages.borrow_mut();
let slot = pages
.get_mut(index)
.ok_or(PvError::PageFault { page_id: id })?;
**slot = *page;
Ok(())
}
pub fn write_pages_from(&self, start_id: u64, pages: &[&PageBuf]) -> Result<()> {
for (i, page) in pages.iter().enumerate() {
self.write_page(start_id + i as u64, page)?;
}
Ok(())
}
pub fn read_page(&self, id: u64) -> Result<PageBuf> {
let index = usize::try_from(id).map_err(|_| PvError::PageFault { page_id: id })?;
self.pages
.borrow()
.get(index)
.cloned()
.ok_or(PvError::PageFault { page_id: id })
}
pub fn read_all_pages(&self) -> Result<Vec<PageBuf>> {
Ok(self.pages.borrow().clone())
}
}
pub trait RangeReader {
fn read_at(&self, offset: u64, len: usize) -> Result<Vec<u8>>;
}
pub struct RemoteStore {
reader: Box<dyn RangeReader>,
page_count: u64,
}
impl RemoteStore {
pub fn new(reader: Box<dyn RangeReader>, page_count: u64) -> Self {
Self { reader, page_count }
}
pub fn page_count(&self) -> u64 {
self.page_count
}
pub fn read_page(&self, id: u64) -> Result<PageBuf> {
if id >= self.page_count {
return Err(PvError::PageFault { page_id: id });
}
let offset = FILE_HEADER_SIZE as u64 + id * PAGE_SIZE as u64;
let bytes = self.reader.read_at(offset, PAGE_SIZE)?;
let arr: [u8; PAGE_SIZE] = bytes
.as_slice()
.try_into()
.map_err(|_| PvError::Corruption("streamed page has the wrong length".into()))?;
Ok(Box::new(arr))
}
pub fn read_all_pages(&self) -> Result<Vec<PageBuf>> {
(0..self.page_count).map(|id| self.read_page(id)).collect()
}
}
pub enum Backend {
Dev(DevStore),
Mem(MemStore),
Prod(Monolith),
Remote(RemoteStore),
}
impl Backend {
pub fn page_count(&self) -> u64 {
match self {
Backend::Dev(d) => d.page_count(),
Backend::Mem(m) => m.page_count(),
Backend::Prod(m) => m.page_count(),
Backend::Remote(r) => r.page_count(),
}
}
pub fn read_page(&self, id: u64) -> Result<PageBuf> {
match self {
Backend::Dev(d) => d.read_page(id),
Backend::Mem(m) => m.read_page(id),
Backend::Prod(m) => m.read_page(id),
Backend::Remote(r) => r.read_page(id),
}
}
pub fn is_writable(&self) -> bool {
matches!(self, Backend::Dev(_) | Backend::Mem(_))
}
pub fn alloc_page(&mut self) -> Result<u64> {
match self {
Backend::Dev(d) => Ok(d.alloc_page()),
Backend::Mem(m) => Ok(m.alloc_page()),
Backend::Prod(_) | Backend::Remote(_) => Err(PvError::ReadOnly),
}
}
pub fn write_page(&self, id: u64, page: &[u8; PAGE_SIZE]) -> Result<()> {
match self {
Backend::Dev(d) => d.write_page(id, page),
Backend::Mem(m) => m.write_page(id, page),
Backend::Prod(_) | Backend::Remote(_) => Err(PvError::ReadOnly),
}
}
pub fn write_pages_from(&self, start_id: u64, pages: &[&PageBuf]) -> Result<()> {
match self {
Backend::Dev(d) => d.write_pages_from(start_id, pages),
Backend::Mem(m) => m.write_pages_from(start_id, pages),
Backend::Prod(_) | Backend::Remote(_) => Err(PvError::ReadOnly),
}
}
pub fn sync_data(&self) -> Result<()> {
match self {
Backend::Dev(d) => d.sync_data(),
_ => Ok(()),
}
}
pub fn read_all_pages(&self) -> Result<Vec<PageBuf>> {
match self {
Backend::Dev(d) => d.read_all_pages(),
Backend::Mem(m) => m.read_all_pages(),
Backend::Prod(m) => (0..m.page_count()).map(|id| m.read_page(id)).collect(),
Backend::Remote(r) => r.read_all_pages(),
}
}
}
pub fn bake_monolith_bytes(
pages: &[PageBuf],
cas_pool: &[u8],
manifest_json: &[u8],
) -> Result<Vec<u8>> {
bake_monolith_bytes_with_index(pages, cas_pool, &[], manifest_json, FORMAT_VERSION_BASE)
}
pub fn bake_monolith_bytes_with_index(
pages: &[PageBuf],
cas_pool: &[u8],
index_region: &[u8],
manifest_json: &[u8],
format_version: u16,
) -> Result<Vec<u8>> {
let overflow = || PvError::Corruption("monolith size overflows address space".into());
let cas_offset = pages
.len()
.checked_mul(PAGE_SIZE)
.and_then(|n| n.checked_add(FILE_HEADER_SIZE))
.ok_or_else(overflow)?;
let index_offset = cas_offset
.checked_add(cas_pool.len())
.ok_or_else(overflow)?;
let manifest_offset = index_offset
.checked_add(index_region.len())
.ok_or_else(overflow)?;
let total = manifest_offset
.checked_add(manifest_json.len())
.ok_or_else(overflow)?;
let header =
FileHeader::new_versioned(manifest_offset as u64, cas_offset as u64, format_version);
let mut out = Vec::with_capacity(total);
out.extend_from_slice(&header.encode());
for page in pages {
out.extend_from_slice(&page[..]);
}
out.extend_from_slice(cas_pool);
out.extend_from_slice(index_region);
out.extend_from_slice(manifest_json);
Ok(out)
}
pub fn bake_monolith(
out_path: impl AsRef<Path>,
pages: &[PageBuf],
cas_pool: &[u8],
manifest_json: &[u8],
) -> Result<()> {
let bytes = bake_monolith_bytes(pages, cas_pool, manifest_json)?;
let mut out = File::create(out_path)?;
out.write_all(&bytes)?;
out.flush()?;
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn dev_store_round_trips_pages() {
let tmp = tempfile::tempdir().unwrap();
let mut dev = DevStore::create(tmp.path()).unwrap();
let id0 = dev.alloc_page();
let id1 = dev.alloc_page();
let mut p0: PageBuf = Box::new([0u8; PAGE_SIZE]);
p0[0] = 0xAA;
let mut p1: PageBuf = Box::new([0u8; PAGE_SIZE]);
p1[4095] = 0xBB;
dev.write_page(id0, &p0).unwrap();
dev.write_page(id1, &p1).unwrap();
assert_eq!(dev.read_page(id0).unwrap()[0], 0xAA);
assert_eq!(dev.read_page(id1).unwrap()[4095], 0xBB);
assert!(matches!(dev.read_page(2), Err(PvError::PageFault { .. })));
}
#[test]
fn bake_then_open_monolith_matches_pages() {
let tmp = tempfile::tempdir().unwrap();
let mut dev = DevStore::create(tmp.path().join("ws")).unwrap();
let id = dev.alloc_page();
let mut page: PageBuf = Box::new([0u8; PAGE_SIZE]);
page[10] = 0x42;
dev.write_page(id, &page).unwrap();
let pages = dev.read_all_pages().unwrap();
let cas_pool = b"blobpool".to_vec();
let manifest = br#"{"ok":true}"#.to_vec();
let out = tmp.path().join("db.pvdb");
bake_monolith(&out, &pages, &cas_pool, &manifest).unwrap();
let mono = Monolith::open(&out).unwrap();
assert_eq!(mono.page_count(), 1);
assert_eq!(mono.read_page(0).unwrap()[10], 0x42);
assert_eq!(mono.manifest_bytes(), manifest.as_slice());
let pool_end = mono.cas_offset() + cas_pool.len();
assert_eq!(
&mono.mmap()[mono.cas_offset()..pool_end],
cas_pool.as_slice()
);
std::fs::write(&out, vec![0u8; FILE_HEADER_SIZE]).unwrap();
assert_eq!(mono.read_page(0).unwrap()[10], 0x42);
assert_eq!(mono.manifest_bytes(), manifest.as_slice());
}
#[test]
fn open_rejects_bad_magic() {
let tmp = tempfile::tempdir().unwrap();
let path = tmp.path().join("bad.pvdb");
std::fs::write(&path, vec![0u8; 64]).unwrap();
assert!(matches!(
Monolith::open(&path),
Err(PvError::SignatureMismatch { .. })
));
}
#[test]
fn sync_data_fsyncs_all_dirty_chunks() {
let tmp = tempfile::tempdir().unwrap();
let dev = DevStore::create(tmp.path()).unwrap();
let page = [7u8; PAGE_SIZE];
dev.write_page(0, &page).unwrap(); dev.write_page(PAGES_PER_CHUNK, &page).unwrap(); dev.sync_data().unwrap();
assert!(tmp.path().join("chunks").join("chunk_00000.pvd").exists());
assert!(tmp.path().join("chunks").join("chunk_00001.pvd").exists());
}
#[test]
fn page_checksum_excludes_its_own_field_and_is_nonzero() {
let mut page: PageBuf = Box::new([0u8; PAGE_SIZE]);
page[0] = 0xAB;
page[100] = 0xCD;
let c1 = page_checksum(&page);
assert_ne!(c1, 0);
page[PAGE_CHECKSUM_OFFSET..PAGE_CHECKSUM_OFFSET + 4].copy_from_slice(&[1, 2, 3, 4]);
assert_eq!(page_checksum(&page), c1);
}
#[test]
fn stamp_then_verify_round_trips() {
let mut page: PageBuf = Box::new([0u8; PAGE_SIZE]);
page[42] = 0x7F;
stamp_page_checksum(&mut page);
assert!(verify_page_checksum(7, &page).is_ok());
}
#[test]
fn verify_detects_a_flipped_body_byte() {
let mut page: PageBuf = Box::new([0u8; PAGE_SIZE]);
page[42] = 0x7F;
stamp_page_checksum(&mut page);
page[42] ^= 0x01; assert!(matches!(
verify_page_checksum(7, &page),
Err(PvError::Corruption(_))
));
}
#[test]
fn verify_detects_a_corrupt_checksum_field() {
let mut page: PageBuf = Box::new([0u8; PAGE_SIZE]);
page[42] = 0x7F;
stamp_page_checksum(&mut page);
page[PAGE_CHECKSUM_OFFSET] ^= 0xFF; assert!(matches!(
verify_page_checksum(7, &page),
Err(PvError::Corruption(_))
));
}
#[test]
fn verify_accepts_an_unstamped_blank_page() {
let page: PageBuf = Box::new([0u8; PAGE_SIZE]);
assert!(verify_page_checksum(0, &page).is_ok());
}
}