Struct VirtioBlkBlockIo

pub struct VirtioBlkBlockIo<'a> {
    driver: &'a mut VirtioBlkDriver,
    dma_buffer: &'a mut [u8],
    dma_buffer_phys: u64,
    next_request_id: u32,
    timeout_ticks: u64,
}

BlockIo adapter for VirtIO-blk driver.

Provides synchronous block I/O by wrapping the async VirtIO-blk driver and using a DMA-capable buffer for transfers.

Fields

driver: &'a mut VirtioBlkDriver

The underlying VirtIO-blk driver

dma_buffer: &'a mut [u8]

DMA buffer for transfers (must be physically contiguous)

dma_buffer_phys: u64

Physical address of DMA buffer

next_request_id: u32

Next request ID

timeout_ticks: u64

Timeout in TSC ticks

Implementations

impl<'a> VirtioBlkBlockIo<'a>

pub const MAX_TRANSFER_SIZE: usize = 65_536usize

Maximum transfer size per request (64KB default)

pub fn new( driver: &'a mut VirtioBlkDriver, dma_buffer: &'a mut [u8], dma_buffer_phys: u64, timeout_ticks: u64, ) -> Result<Self, BlockIoError>

Create a new BlockIo adapter.

Arguments

• driver - VirtIO-blk driver
• dma_buffer - DMA-capable buffer (must be at least MAX_TRANSFER_SIZE bytes)
• dma_buffer_phys - Physical address of DMA buffer
• timeout_ticks - Timeout for I/O operations in TSC ticks

Returns

New adapter or error if buffer too small

fn wait_for_completion(&mut self, request_id: u32) -> Result<(), BlockIoError>

Wait for a specific request to complete.

fn sync_read( &mut self, sector: u64, num_sectors: u32, dst: &mut [u8], ) -> Result<(), BlockIoError>

Perform a synchronous read.

fn sync_write( &mut self, sector: u64, num_sectors: u32, src: &[u8], ) -> Result<(), BlockIoError>

Perform a synchronous write.

Trait Implementations

impl<'a> BlockIo for VirtioBlkBlockIo<'a>

type Error = BlockIoError

IO error type.

fn block_size(&self) -> BlockSize

Get the [BlockSize]. The return value is not allowed to change.

fn num_blocks(&mut self) -> Result<u64, Self::Error>

Get the number of logical blocks in the disk.

fn read_blocks( &mut self, start_lba: Lba, dst: &mut [u8], ) -> Result<(), Self::Error>

Read contiguous blocks from the disk. The dst buffer size must be a multiple of block_size. Implementations are permitted to panic if this precondition is not met, e.g. by calling [BlockSize::assert_valid_block_buffer].

fn write_blocks( &mut self, start_lba: Lba, src: &[u8], ) -> Result<(), Self::Error>

Write contiguous block to the disk. The src buffer size must be a multiple of block_size. Implementations are permitted to panic if this precondition is not met, e.g. by calling [BlockSize::assert_valid_block_buffer].

fn flush(&mut self) -> Result<(), Self::Error>

Flush any pending writes to the device.