Struct IoBlockDevice 

pub struct IoBlockDevice<T> { /* private fields */ }

A block device backed by any type implementing Read + Write + Seek.

This is useful for using files, memory buffers, or any seekable I/O as a block device.

Implementations

impl<T> IoBlockDevice<T>

where T: Read + Write + Seek,

pub fn new(inner: T, block_size: u32, total_size: u64) -> Self

Create a new IoBlockDevice wrapping the given I/O object.

Arguments

• inner - The underlying I/O object
• block_size - Block size in bytes (typically 512 or 4096)
• total_size - Total size of the device in bytes

Examples found in repository

examples/mkfs_file.rs (line 27)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let path = "test_disk.img";
    let size: u64 = 10 * 1024 * 1024; // 10 MB

    println!("Creating disk image: {} ({} bytes)", path, size);

    // Create and size the file
    {
        let mut file = File::create(path)?;
        file.seek(SeekFrom::Start(size - 1))?;
        file.write_all(&[0])?;
        file.sync_all()?;
    }

    // Open for read/write
    let file = OpenOptions::new().read(true).write(true).open(path)?;

    // Create block device wrapper (512-byte sectors)
    let device = IoBlockDevice::new(file, 512, size);

    // Configure and create filesystem
    let config = MkfsConfig::new()
        .fs_type(FsType::Ext4)
        .block_size(4096)
        .label("test_volume");

    println!("Formatting as ext4...");
    mkfs(device, config)?;

    println!("Done! You can verify with: file {} or dumpe2fs {}", path, path);

    Ok(())
}

pub fn inner(&self) -> &T

Get a reference to the underlying I/O object.

pub fn inner_mut(&mut self) -> &mut T

Get a mutable reference to the underlying I/O object.

pub fn into_inner(self) -> T

Consume the wrapper and return the underlying I/O object.

Trait Implementations

impl<T> BlockDevice for IoBlockDevice<T>

where T: Read + Write + Seek + Send,

fn block_size(&self) -> u32

Returns the physical block size in bytes.

fn block_count(&self) -> u64

Returns the total number of blocks.

fn read_blocks( &mut self, buf: &mut [u8], block_id: u64, block_count: u32, ) -> Result<()>

Read blocks from the device.

fn write_blocks( &mut self, buf: &[u8], block_id: u64, block_count: u32, ) -> Result<()>

Write blocks to the device.

fn open(&mut self) -> Result<()>

Open the device (optional).

fn close(&mut self) -> Result<()>

Close the device (optional).