Struct FileStore 

pub(crate) struct FileStore {
    classes: Vec<Class>,
    io_mode: IoMode,
    page: usize,
    capacity: AtomicU64,
    capacity_limit: u64,
    dir: PathBuf,
    allocated: AtomicU64,
    punching: AtomicU64,
    writes_disabled: AtomicBool,
    enospc_seen: AtomicBool,
    counters: Counters,
}

Available on Unix and crate feature pool only.

The file-backed extent store. See the module documentation.

Fields

classes: Vec<Class>

io_mode: IoMode

page: usize

capacity: AtomicU64

capacity_limit: u64

The capacity open set. Re-derivation never raises the capacity above it.

dir: PathBuf

allocated: AtomicU64

Bytes of slots with allocated blocks, in use or warm. Exceeds capacity after ENOSPC or a re-derivation lowers the capacity, until slots are punched.

punching: AtomicU64

Bytes of slots taken off a warm list to be punched and not yet put back. They are still charged to allocated.

writes_disabled: AtomicBool

enospc_seen: AtomicBool

counters: Counters

Implementations

impl FileStore

pub(crate) fn open( dir: &Path, capacity_bytes: Option<u64>, classes: &[usize], ) -> Result<FileStore>

Opens one anonymous file per entry of classes in dir. classes is the ladder of slot sizes, ascending page multiples. capacity_bytes None derives capacity from the volume per derived_capacity.

Fails with io::ErrorKind::Unsupported when dir is on a memory-backed filesystem or the platform is not Linux, and with io::ErrorKind::StorageFull when a derived capacity cannot hold one slot of the largest class.

pub(crate) fn io_mode(&self) -> IoMode

pub(crate) fn class_for(&self, comp_len: usize) -> Option<usize>

The class for a stored payload of comp_len bytes, None if none fits.

pub(crate) fn class_size(&self, class: usize) -> usize

pub(crate) fn alloc(&self, class: usize) -> Result<FileSlot, AllocError>

Reserves a slot with allocated blocks.

pub(crate) fn free(&self, slot: FileSlot)

Returns a slot. Its blocks stay allocated. Must not be called while a read or write of the slot is in flight, since the slot can be punched or handed out again at once.

pub(crate) fn write( &self, slot: FileSlot, buf: &[u8], len: usize, ) -> Result<usize, WriteError>

Writes buf[..round_up(len, page)] to slot and returns the rounded length. buf must be at least that long, and page aligned in IoMode::Direct. Fails without I/O once writes are disabled. On ENOSPC, takes the slot back and fails with WriteError::Full. On any other I/O error, disables further writes for the store’s lifetime.

fn reclaim_after_enospc(&self, slot: FileSlot)

Takes back slot after a write to it hit ENOSPC, and lowers the capacity.

fn lower_capacity(&self, op: &str)

Lowers the capacity to the bytes allocated now, after op hit ENOSPC.

pub(crate) fn read( &self, slot: FileSlot, len: usize, crc: u32, dst: &mut AlignedBuf, ) -> usize

Reads the slot’s first len stored bytes into dst (resized to len), verifying crc, and returns the length transferred, len rounded up to a page. Panics on I/O error, short read, or checksum mismatch.

pub(crate) fn capacity_bytes(&self) -> u64

pub(crate) fn writes_disabled(&self) -> bool

pub(crate) fn can_alloc(&self, class: usize) -> bool

Whether an alloc of class could currently succeed without I/O errors: writes enabled and either a warm free slot, capacity room, or room after punching other classes’ warm slots exists. Takes no lock.

pub(crate) fn can_alloc_any(&self) -> bool

Whether FileStore::can_alloc holds for some class.

pub(crate) fn release_warm(&self, max_bytes: u64) -> u64

Punches warm slots of every class, up to max_bytes per class rounded up to a whole slot, and returns the bytes punched.

pub(crate) fn refresh_capacity(&self)

Sets the capacity to the bytes allocated plus the volume’s usable_bytes, at most the capacity open set. Keeps the capacity if the volume cannot be queried.

pub(crate) fn stats(&self) -> FileStoreStats

fn offset(&self, slot: FileSlot) -> u64

fn fits(&self, size: u64) -> bool

fn reserve(&self, size: u64) -> bool

Charges size bytes against capacity, or returns false if they do not fit.

fn punch_for(&self, class: usize, size: u64) -> bool

Punches warm slots of classes other than class until size more bytes fit or no other class has a warm slot, and returns whether they fit.

fn punch_warm(&self, class: usize, want: u64) -> (u64, bool)

Punches warm slots of class until at least want bytes are punched or none is left, moving them cold. Returns the bytes punched and whether a punch failed, which leaves the failed slot and the ones not yet punched warm.

fn disable_writes(&self, op: &str, err: &Error)

Trait Implementations

impl Debug for FileStore

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.