#![deny(warnings)]
#![forbid(unsafe_code)]
use core::fmt;
use std::path::Path;
pub use store_io_buf::IoBuf;
pub use store_io_core::error::OsError;
pub use store_io_core::evidence::Evidence;
pub type RawResult<T> = Result<T, OsError>;
#[derive(Clone, PartialEq, Eq, Hash)]
pub struct FileName(String);
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct InvalidFileName;
impl fmt::Display for InvalidFileName {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str("not a single path component (1-255 bytes, no separators, not . or .., no NUL)")
}
}
impl std::error::Error for InvalidFileName {}
impl FileName {
pub fn new(name: &str) -> Result<Self, InvalidFileName> {
let bad = name.is_empty()
|| name.len() > 255
|| name == "."
|| name == ".."
|| name
.bytes()
.any(|b| b == b'/' || b == b'\\' || b == 0 || b == b':');
if bad {
Err(InvalidFileName)
} else {
Ok(Self(name.to_owned()))
}
}
#[must_use]
pub fn as_str(&self) -> &str {
&self.0
}
}
impl fmt::Debug for FileName {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::Debug::fmt(&self.0, f)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum FileMode {
ReadWrite,
ReadOnly,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ReleaseHow {
Deallocate,
TrimInPlace,
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub struct RangeState {
pub unwritten: store_io_core::evidence::Tri,
pub shared: store_io_core::evidence::Tri,
pub cached_pages: Option<u64>,
pub valid_data: store_io_core::evidence::Tri,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct QueueConfig {
pub depth: u32,
}
impl Default for QueueConfig {
fn default() -> Self {
Self { depth: 64 }
}
}
#[derive(Debug)]
pub enum IoOp<'a, F> {
Write {
file: &'a F,
offset: u64,
buf: IoBuf,
dsync: bool,
},
Read {
file: &'a F,
offset: u64,
buf: IoBuf,
},
FlushData {
file: &'a F,
},
}
#[derive(Debug)]
pub struct Completion {
pub tag: u64,
pub buf: Option<IoBuf>,
pub result: RawResult<usize>,
}
#[derive(Debug)]
pub struct Rejected {
pub buf: Option<IoBuf>,
pub raw: Option<OsError>,
}
#[derive(Debug)]
pub struct CompletionBuf {
items: Vec<Completion>,
cap: usize,
}
impl CompletionBuf {
#[must_use]
pub fn with_capacity(cap: usize) -> Self {
Self {
items: Vec::with_capacity(cap),
cap,
}
}
#[must_use]
pub fn room(&self) -> usize {
self.cap - self.items.len()
}
pub fn push(&mut self, c: Completion) -> Result<(), Completion> {
if self.items.len() == self.cap {
return Err(c);
}
self.items.push(c);
Ok(())
}
pub fn drain(&mut self) -> std::vec::Drain<'_, Completion> {
self.items.drain(..)
}
#[must_use]
pub fn len(&self) -> usize {
self.items.len()
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.items.is_empty()
}
}
pub trait Queue {
type File;
fn submit(&mut self, op: IoOp<'_, Self::File>, tag: u64) -> Result<(), Rejected>;
fn reap(&mut self, out: &mut CompletionBuf) -> usize;
fn wait(&mut self, min: usize, out: &mut CompletionBuf) -> RawResult<usize>;
fn in_flight(&self) -> usize;
}
pub trait Platform: Send + Sync + 'static {
type File: Send + Sync;
type Dir: Send + Sync;
type Lock: Send + Sync;
type Queue: Queue<File = Self::File>;
fn open_dir(&self, path: &Path, create: bool) -> RawResult<Self::Dir>;
fn create_file(&self, dir: &Self::Dir, name: &FileName) -> RawResult<Self::File>;
fn open_file(&self, dir: &Self::Dir, name: &FileName, mode: FileMode) -> RawResult<Self::File>;
fn rename_replace(
&self,
dir: &Self::Dir,
from: &FileName,
to: &FileName,
file: &Self::File,
) -> RawResult<()>;
fn unlink(&self, dir: &Self::Dir, name: &FileName) -> RawResult<()>;
fn sync_dir(&self, dir: &Self::Dir) -> RawResult<()>;
fn lock_exclusive(&self, file: &Self::File) -> RawResult<Self::Lock>;
fn set_len(&self, file: &Self::File, len: u64) -> RawResult<()>;
fn allocate(&self, file: &Self::File, len: u64) -> RawResult<()>;
fn size(&self, file: &Self::File) -> RawResult<u64>;
fn release_range(
&self,
file: &Self::File,
offset: u64,
len: u64,
how: ReleaseHow,
) -> RawResult<()>;
fn range_state(&self, file: &Self::File, offset: u64, len: u64) -> RawResult<RangeState>;
fn flush_all(&self, file: &Self::File) -> RawResult<()>;
fn probe(&self, dir: &Self::Dir, file: &Self::File) -> RawResult<Evidence>;
fn queue(&self, cfg: QueueConfig) -> RawResult<Self::Queue>;
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_file_name_rejects_escapes_and_separators() {
for bad in ["", ".", "..", "a/b", "a\\b", "c:x", "nul\0"] {
assert!(FileName::new(bad).is_err(), "{bad:?}");
}
assert!(FileName::new(&"x".repeat(256)).is_err());
assert_eq!(
FileName::new("store.sio").map(|n| n.as_str().to_owned()),
Ok("store.sio".to_owned())
);
}
#[test]
fn test_completion_buf_never_grows() {
let mut b = CompletionBuf::with_capacity(1);
assert!(
b.push(Completion {
tag: 1,
buf: None,
result: Ok(0)
})
.is_ok()
);
assert!(
b.push(Completion {
tag: 2,
buf: None,
result: Ok(0)
})
.is_err()
);
assert_eq!(b.room(), 0);
assert_eq!(b.drain().map(|c| c.tag).collect::<Vec<_>>(), vec![1]);
assert!(b.is_empty());
}
}