Struct devices::virtio::virtio_mmio_device::VirtioMmioDevice

pub struct VirtioMmioDevice {

    device: Box<dyn VirtioDevice>,
    device_activated: bool,
    interrupt: Option<Interrupt>,
    interrupt_evt: Option<IrqEdgeEvent>,
    async_intr_status: bool,
    queues: Vec<QueueConfig>,
    queue_evts: Vec<Event>,
    mem: GuestMemory,
    device_feature_select: u32,
    driver_feature_select: u32,
    queue_select: u16,
    driver_status: u8,
    mmio_base: u64,
    irq_num: u32,
    config_generation: u32,
}

Implements the MMIO transport for virtio devices.

Fields

device: Box<dyn VirtioDevice>

device_activated: bool

interrupt: Option<Interrupt>

interrupt_evt: Option<IrqEdgeEvent>

async_intr_status: bool

queues: Vec<QueueConfig>

queue_evts: Vec<Event>

mem: GuestMemory

device_feature_select: u32

driver_feature_select: u32

queue_select: u16

driver_status: u8

mmio_base: u64

irq_num: u32

config_generation: u32

Implementations

impl VirtioMmioDevice

pub fn new( mem: GuestMemory, device: Box<dyn VirtioDevice>, async_intr_status: bool ) -> Result<Self>

Constructs a new MMIO transport for the given virtio device.

pub fn ioevents(&self) -> Vec<(&Event, u64, Datamatch)>

fn is_driver_ready(&self) -> bool

fn is_reset_requested(&self) -> bool

Determines if the driver has requested the device reset itself

fn device_type(&self) -> u32

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

Activates the underlying VirtioDevice. assign_irq has to be called first.

fn read_mmio(&self, info: BusAccessInfo, data: &mut [u8])

fn write_mmio(&mut self, info: BusAccessInfo, data: &[u8])

fn with_queue<U, F>(&self, f: F) -> Option<U>where F: FnOnce(&QueueConfig) -> U,

fn with_queue_mut<F>(&mut self, f: F)where F: FnOnce(&mut QueueConfig),

pub fn allocate_regions( &mut self, resources: &mut SystemAllocator ) -> Result<Vec<(u64, u64)>, Error>

pub fn assign_irq(&mut self, irq_evt: &IrqEdgeEvent, irq_num: u32)

pub fn keep_rds(&self) -> Vec<RawDescriptor>

fn on_device_sandboxed(&mut self)

pub fn generate_acpi(&mut self, sdts: Vec<SDT>) -> Option<Vec<SDT>>

Trait Implementations

impl Aml for VirtioMmioDevice

fn to_aml_bytes(&self, bytes: &mut Vec<u8>)

Translate an ACPI object into AML code and append to the vector buffer.

impl BusDevice for VirtioMmioDevice

fn debug_label(&self) -> String

Returns a label suitable for debug output.

fn device_id(&self) -> DeviceId

Returns a unique id per device type suitable for metrics gathering.

fn read(&mut self, info: BusAccessInfo, data: &mut [u8])

Reads at offset from this device

fn write(&mut self, info: BusAccessInfo, data: &[u8])

Writes at offset into this device

fn on_sandboxed(&mut self)

Invoked when the device is sandboxed.

fn config_register_write( &mut self, reg_idx: usize, offset: u64, data: &[u8] ) -> ConfigWriteResult

Sets a register in the configuration space. Only used by PCI.

fn config_register_read(&self, reg_idx: usize) -> u32

Gets a register from the configuration space. Only used by PCI.

fn init_pci_config_mapping( &mut self, shmem: &SharedMemory, base: usize, len: usize ) -> bool

Provides a memory region to back MMIO access to the configuration space. If the device can keep the memory region up to date, then it should return true, after which no more calls to config_register_read will be made. Otherwise the device should return false.

fn virtual_config_register_write(&mut self, reg_idx: usize, value: u32)

Sets a register in the virtual config space. Only used by PCI.

fn virtual_config_register_read(&self, reg_idx: usize) -> u32

Gets a register from the virtual config space. Only used by PCI.

fn get_ranges(&self) -> Vec<(BusRange, BusType)>

Gets a list of all ranges registered by this BusDevice.

fn destroy_device(&mut self)

Invoked when the device is destroyed

fn is_bridge(&self) -> Option<u8>

Returns the secondary bus number if this bus device is pci bridge

impl BusDeviceObj for VirtioMmioDevice

fn as_virtio_mmio_device(&self) -> Option<&VirtioMmioDevice>

fn as_virtio_mmio_device_mut(&mut self) -> Option<&mut VirtioMmioDevice>

fn into_virtio_mmio_device(self: Box<Self>) -> Option<Box<VirtioMmioDevice>>

fn as_pci_device(&self) -> Option<&dyn PciDevice>

fn as_pci_device_mut(&mut self) -> Option<&mut dyn PciDevice>

fn into_pci_device(self: Box<Self>) -> Option<Box<dyn PciDevice>>

fn as_platform_device(&self) -> Option<&VfioPlatformDevice>

fn as_platform_device_mut(&mut self) -> Option<&mut VfioPlatformDevice>

fn into_platform_device(self: Box<Self>) -> Option<Box<VfioPlatformDevice>>

impl Suspendable for VirtioMmioDevice

fn snapshot(&mut self) -> Result<Value>

Save the device state in an image that can be restored.

fn restore(&mut self, _data: Value) -> Result<()>

Load a saved snapshot of an image.

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

Stop all threads related to the device. Sleep should be idempotent.

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

Create/Resume all threads related to the device. Wake should be idempotent.