Struct VirtioBlockDevice

pub struct VirtioBlockDevice {
    base_addr: usize,
    virtqueues: Mutex<[VirtQueue<'static>; 1]>,
    capacity: RwLock<u64>,
    sector_size: RwLock<u32>,
    features: RwLock<u32>,
    read_only: RwLock<bool>,
    request_queue: Mutex<Vec<Box<BlockIORequest>>>,
}

Fields

base_addr: usize

virtqueues: Mutex<[VirtQueue<'static>; 1]>

capacity: RwLock<u64>

sector_size: RwLock<u32>

features: RwLock<u32>

read_only: RwLock<bool>

request_queue: Mutex<Vec<Box<BlockIORequest>>>

Implementations

impl VirtioBlockDevice

pub fn new(base_addr: usize) -> Self

fn process_request(&self, req: &mut BlockIORequest) -> Result<(), &'static str>

Trait Implementations

impl BlockDevice for VirtioBlockDevice

fn get_disk_name(&self) -> &'static str

Get the disk name

fn get_disk_size(&self) -> usize

Get the disk size in bytes

fn enqueue_request(&self, request: Box<BlockIORequest>)

Enqueue a block I/O request

fn process_requests(&self) -> Vec<BlockIOResult>

Process all queued requests

impl Device for VirtioBlockDevice

fn device_type(&self) -> DeviceType

fn name(&self) -> &'static str

fn as_any(&self) -> &dyn Any

fn as_any_mut(&mut self) -> &mut dyn Any

fn as_block_device(&self) -> Option<&dyn BlockDevice>

Cast to BlockDevice if this device is a block device

fn as_char_device(&self) -> Option<&dyn CharDevice>

Cast to CharDevice if this device is a character device

impl VirtioDevice for VirtioBlockDevice

fn get_base_addr(&self) -> usize

fn get_virtqueue_count(&self) -> usize

fn get_supported_features(&self, device_features: u32) -> u32

Get device features supported by this driver

fn get_queue_desc_addr(&self, queue_idx: usize) -> Option<u64>

Get the descriptor address for a virtqueue

fn get_queue_driver_addr(&self, queue_idx: usize) -> Option<u64>

Get the driver area address for a virtqueue

fn get_queue_device_addr(&self, queue_idx: usize) -> Option<u64>

Get the device area address for a virtqueue

fn init(&mut self) -> Result<(), &'static str>

Initialize the device

fn reset(&mut self)

Reset the device by writing 0 to the Status register

fn acknowledge(&mut self)

Set ACKNOWLEDGE status bit

fn driver(&mut self)

Set DRIVER status bit

fn driver_ok(&mut self)

Set DRIVER_OK status bit

fn set_failed(&mut self)

Set FAILED status bit

fn negotiate_features(&mut self) -> bool

Negotiate device features

fn setup_queue(&mut self, queue_idx: usize) -> bool

Set up a virtqueue

fn read_config<T: Sized>(&self, offset: usize) -> T

Read device-specific configuration

fn write_config<T: Sized>(&self, offset: usize, value: T)

Write device-specific configuration

fn get_device_info(&self) -> (u32, u32)

Get device and vendor IDs

fn get_interrupt_status(&self) -> u32

Get interrupt status

fn process_interrupts(&mut self) -> u32

Process interrupts (polling method)

fn memory_barrier(&self)

Memory barrier for ensuring memory operations ordering

fn notify(&self, virtqueue_idx: usize)

Notify the device about new buffers in a specified virtqueue

fn read32_register(&self, register: Register) -> u32

Read a 32-bit value from a device register

fn write32_register(&self, register: Register, value: u32)

Write a 32-bit value to a device register

fn read64_register(&self, register: Register) -> u64

Read a 64-bit value from a device register

fn write64_register(&self, register: Register, value: u64)

Write a 64-bit value to a device register