Struct IsoBlockIoAdapter

pub struct IsoBlockIoAdapter<'a, B: BlockIo> {
    ctx: IsoReadContext,
    block_io: &'a mut B,
}

Block I/O adapter that implements gpt_disk_io::BlockIo

This allows iso9660 to read from chunked ISO storage transparently. The adapter translates virtual sector addresses to physical disk locations.

iso9660 uses 2048-byte sectors, but physical disk uses 512-byte blocks. This adapter handles the translation.

Fields

ctx: IsoReadContext

ISO read context (chunk partition info)

block_io: &'a mut B

Underlying block device

Implementations

impl<'a, B: BlockIo> IsoBlockIoAdapter<'a, B>

pub fn new(ctx: IsoReadContext, block_io: &'a mut B) -> Self

Create a new adapter

Arguments

• ctx - ISO read context from IsoStorageManager
• block_io - Underlying disk block device

pub fn total_size(&self) -> u64

Get total size in bytes

pub fn total_iso_sectors(&self) -> u64

Get total number of ISO sectors (2048-byte sectors)

fn find_chunk_for_offset(&self, byte_offset: u64) -> Option<(usize, u64)>

Find which chunk contains a given byte offset

fn translate_byte_offset_to_disk_lba(&self, byte_offset: u64) -> Option<u64>

Translate ISO byte offset to physical disk LBA (512-byte sectors)

Trait Implementations

impl<'a, B: BlockIo> BlockIo for IsoBlockIoAdapter<'a, B>

type Error = <B as BlockIo>::Error

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, buffer: &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, _buffer: &[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.