Struct AlignedDevice 

pub struct AlignedDevice<D: BlockDevice> { /* private fields */ }

Presents a byte-granular BlockDevice over one that accepts only requests whose offset and length are multiples of sector (#373).

The engine reads 1024 bytes at offset 1024 for the superblock, and its write path passes sub-block writes through; a host block resource that only takes sector-aligned I/O refuses both. Here:

• an aligned request passes straight through, with no copy;
• an unaligned read reads the enclosing aligned span into a bounce buffer and copies the requested slice out;
• an unaligned write reads the enclosing span’s first and last sectors, patches the caller’s bytes in, and writes the whole span back as one aligned request.

Every write holds one lock, so a read-modify-write can neither lose nor be lost to a concurrent write into the same sector.

Implementations

impl<D: BlockDevice> AlignedDevice<D>

pub fn new(inner: D, sector: u32) -> Self

Wrap inner, whose requests must be multiples of sector bytes. sector must be a power of two.

Trait Implementations

impl<D: BlockDevice> BlockDevice for AlignedDevice<D>

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.