Struct CoreDevice 

pub struct CoreDevice<T: BlockDevice> { /* private fields */ }

Wraps any fs_core::BlockDevice and presents it as an ext4 BlockDevice. Journal-cache hooks default to no-ops (the underlying device has no notion of “pinned” pages), which is the same as ext4’s behaviour against a raw FileDevice — safe because un-cached devices imply no separate journal log either.

Implementations

impl<T: BlockDevice> CoreDevice<T>

pub fn new(inner: T) -> Self

pub fn inner(&self) -> &T

Borrow the wrapped device, e.g. for diagnostics.

pub fn into_inner(self) -> T

Consume the wrapper and return the inner device.

Trait Implementations

impl<T: BlockDevice> BlockDevice for CoreDevice<T>

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

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

fn size_bytes(&self) -> u64

Total device size in bytes (for bounds-checking).

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

Write exactly buf.len() bytes at offset. Default: returns an error for read-only devices. Writable devices override this.

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

Flush any pending writes to stable storage. Default: no-op for read-only devices; writable devices should implement fsync semantics.

fn is_writable(&self) -> bool

Reports whether write_at is likely to succeed. Used by the mount path to decide whether journal replay is possible.

fn populate_cache(&self, _block: u64, _bytes: Vec<u8>)

Buffer-cache hook: stash bytes for block so a subsequent read_at returns those bytes instead of reading from physical storage. Used by a read-only mount’s journal replay to make committed metadata visible to readers without writing it back to the data area on disk.

fn unpin_all(&self)

Buffer-cache hook: tell the device the journal has been checkpointed, so any blocks pinned via populate_cache are now consistent with disk and can be evicted under normal LRU pressure. No-op for un-cached devices.

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

Discard clean read-cache entries. Pinned journal metadata must be checkpointed and unpinned first; cached implementations reject otherwise. This does not flush writes and requires exclusive filesystem ownership.