Struct FileDevice 

pub struct FileDevice { /* private fields */ }

A file opened as a block device.

Reads do not take the lock; writes do

A read was seek then read under a mutex, which made the file’s cursor shared state: two threads reading different offsets had to take turns, not because the device could not serve them at once but because one would have moved the other’s cursor.

On Unix the cursor is not involved at all — pread takes the offset as an argument — so reads run without the lock and genuinely overlap.

On Windows the equivalent (seek_read) does move the file pointer, so the lock stays there. Same behaviour, one platform paying for it.

Writes keep the lock on both, because write_at is still seek plus write_all and a partial write must not have another writer’s seek land in the middle of it.

Implementations

impl FileDevice

pub fn open<P: AsRef<Path>>(path: P) -> Result<Self>

Open read-only.

pub fn open_rw<P: AsRef<Path>>(path: P) -> Result<Self>

Open read-write. Errors if the path is not writable.

pub fn open_best_effort<P: AsRef<Path>>(path: P) -> Result<Self>

Open read-write if possible, fall back to read-only otherwise.

Trait Implementations

impl BlockDevice for FileDevice

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 FileDevice

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.