Struct CachingDevice 

pub struct CachingDevice { /* private fields */ }

LRU read-cache wrapper.

It caches a READ device, and writes through one only if it has one

This took an Arc<dyn BlockDevice> — the read write trait — and every driver in this family mounts a volume through an Arc<dyn BlockRead>. So a read-only mount could not wrap it at all, and four of the six drivers used no cache: not by choice, but because it was not expressible.

The read path never needed to write. It holds the read half now, and the writable half only when the caller had one to give: CachingDevice::new for a device that can be written, CachingDevice::read_only for one that cannot. A write to a cache built the second way is [Error::ReadOnly], which is what the underlying device would have said.

Implementations

impl CachingDevice

pub fn new( inner: Arc<dyn BlockDevice>, block_size: u64, capacity: usize, ) -> Arc<Self>

Cache a device that can be written. Writes invalidate the entries they overlap and go through to inner.

pub fn read_only( inner: Arc<dyn BlockRead>, block_size: u64, capacity: usize, ) -> Arc<Self>

Cache a device that is only ever read.

The case every driver here actually has: a volume mounted for reading, behind a BlockRead that was never a BlockDevice.

pub fn stats(&self) -> (u64, u64)

pub fn invalidate_all(&self)

Trait Implementations

impl BlockDevice for CachingDevice

fn write_at(&self, offset: u64, buf: &[u8]) -> Result<()>

Write exactly buf.len() bytes at offset. Default: returns Error::ReadOnly.

fn flush(&self) -> Result<()>

Flush pending writes to stable storage. No-op by default.

fn is_writable(&self) -> bool

Whether write_at is likely to succeed. Mount paths use this to decide whether to attempt journal replay or stay strict-read-only.

impl BlockRead for CachingDevice

fn read_at(&self, offset: u64, buf: &mut [u8]) -> Result<()>

Read exactly buf.len() bytes starting at offset (bytes from the start of the device).

fn size_bytes(&self) -> u64

Total device size in bytes. Used for bounds checks.