Struct devices::virtio::VirtioPciDevice

pub struct VirtioPciDevice {

    config_regs: PciConfiguration,
    preferred_address: Option<PciAddress>,
    pci_address: Option<PciAddress>,
    device: Box<dyn VirtioDevice>,
    device_activated: bool,
    disable_intx: bool,
    interrupt: Option<Interrupt>,
    interrupt_evt: Option<IrqLevelEvent>,
    queues: Vec<QueueConfig>,
    queue_evts: Vec<QueueEvent>,
    mem: GuestMemory,
    settings_bar: PciBarIndex,
    msix_config: Arc<Mutex<MsixConfig>>,
    pm_config: Arc<Mutex<PmConfig>>,
    common_config: VirtioPciCommonConfig,
    iommu: Option<Arc<Mutex<IpcMemoryMapper>>>,
    shared_memory_vm_memory_client: Option<VmMemoryClient>,
    ioevent_vm_memory_client: VmMemoryClient,
    sleep_state: Option<SleepState>,
    vm_control_tube: Arc<Mutex<Tube>>,
}

Implements the PCI transport for virtio devices.

Fields

config_regs: PciConfiguration

preferred_address: Option<PciAddress>

pci_address: Option<PciAddress>

device: Box<dyn VirtioDevice>

device_activated: bool

disable_intx: bool

interrupt: Option<Interrupt>

interrupt_evt: Option<IrqLevelEvent>

queues: Vec<QueueConfig>

queue_evts: Vec<QueueEvent>

mem: GuestMemory

settings_bar: PciBarIndex

msix_config: Arc<Mutex<MsixConfig>>

pm_config: Arc<Mutex<PmConfig>>

common_config: VirtioPciCommonConfig

iommu: Option<Arc<Mutex<IpcMemoryMapper>>>

shared_memory_vm_memory_client: Option<VmMemoryClient>

ioevent_vm_memory_client: VmMemoryClient

sleep_state: Option<SleepState>

vm_control_tube: Arc<Mutex<Tube>>

Implementations

impl VirtioPciDevice

pub fn new( mem: GuestMemory, device: Box<dyn VirtioDevice>, msi_device_tube: Tube, disable_intx: bool, shared_memory_vm_memory_client: Option<VmMemoryClient>, ioevent_vm_memory_client: VmMemoryClient, vm_control_tube: Tube ) -> Result<Self>

Constructs a new PCI transport for the given virtio device.

fn is_driver_ready(&self) -> bool

fn is_device_suspended(&self) -> bool

fn is_reset_requested(&self) -> bool

Determines if the driver has requested the device reset itself

fn add_settings_pci_capabilities( &mut self, settings_bar: u8 ) -> Result<(), PciDeviceError>

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

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

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

pub fn virtio_device(&self) -> &dyn VirtioDevice

pub fn pci_address(&self) -> Option<PciAddress>

fn handle_pm_status_change(&mut self, status: &PmStatusChange)

Trait Implementations

impl HotPluggable for VirtioPciDevice

fn set_pci_address( &mut self, pci_addr: PciAddress ) -> Result<(), PciDeviceError>

Sets PciAddress to pci_addr

fn configure_io_bars(&mut self) -> Result<(), PciDeviceError>

Configures IO BAR layout without memory alloc.

fn configure_device_bars(&mut self) -> Result<(), PciDeviceError>

Configure device BAR layout without memory alloc.

impl PciDevice for VirtioPciDevice

fn debug_label(&self) -> String

Returns a label suitable for debug output.

fn preferred_address(&self) -> Option<PciAddress>

Preferred PCI address for this device, if any.

fn allocate_address( &mut self, resources: &mut SystemAllocator ) -> Result<PciAddress, PciDeviceError>

Allocate and return an unique bus, device and function number for this device. May be called multiple times; on subsequent calls, the device should return the same address it returned from the first call.

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

A vector of device-specific file descriptors that must be kept open after jailing. Must be called before the process is jailed.

fn assign_irq( &mut self, irq_evt: IrqLevelEvent, pin: PciInterruptPin, irq_num: u32 )

Assign a legacy PCI IRQ to this device. The device may write to irq_evt to trigger an interrupt. When irq_resample_evt is signaled, the device should re-assert irq_evt if necessary.

fn allocate_io_bars( &mut self, resources: &mut SystemAllocator ) -> Result<Vec<BarRange>, PciDeviceError>

Allocates the needed IO BAR space using the allocate function which takes a size and returns an address. Returns a Vec of BarRange{addr, size, prefetchable}.

fn allocate_device_bars( &mut self, resources: &mut SystemAllocator ) -> Result<Vec<BarRange>, PciDeviceError>

Allocates the needed device BAR space. Returns a Vec of BarRange{addr, size, prefetchable}. Unlike MMIO BARs (see allocate_io_bars), device BARs are not expected to incur VM exits

fn destroy_device(&mut self)

Invoked when the device is destroyed

fn get_bar_configuration(&self, bar_num: usize) -> Option<PciBarConfiguration>

Returns the configuration of a base address register, if present.

fn register_device_capabilities(&mut self) -> Result<(), PciDeviceError>

Register any capabilties specified by the device.

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

Reads from a PCI configuration register.

fn write_config_register(&mut self, reg_idx: usize, offset: u64, data: &[u8])

Writes to a PCI configuration register.

fn setup_pci_config_mapping( &mut self, shmem: &SharedMemory, base: usize, len: usize ) -> Result<bool, PciDeviceError>

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 Ok(true), after which no more calls to read_config_register will be made. If support isn’t implemented, it should return Ok(false). Otherwise, it should return an error (a failure here is not treated as a fatal setup error).

fn read_bar(&mut self, bar_index: usize, offset: u64, data: &mut [u8])

Reads from a BAR region mapped in to the device.

fn write_bar(&mut self, bar_index: usize, offset: u64, data: &[u8])

Writes to a BAR region mapped in to the device.

fn on_device_sandboxed(&mut self)

Invoked when the device is sandboxed.

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

fn as_virtio_pci_device(&self) -> Option<&VirtioPciDevice>

fn preferred_irq(&self) -> PreferredIrq

Preferred IRQ for this device. The device may request a specific pin and IRQ number by returning a Fixed value. If a device does not support INTx# interrupts at all, it should return None. Otherwise, an appropriate IRQ will be allocated automatically. The device’s assign_irq function will be called with its assigned IRQ either way.

fn get_vm_memory_client(&self) -> Option<&VmMemoryClient>

Gets a reference to the API client for sending VmMemoryRequest. Any devices that uses ioevents must provide this.

fn read_virtual_config_register(&self, _reg_idx: usize) -> u32

Reads from a virtual config register.

fn write_virtual_config_register(&mut self, _reg_idx: usize, _value: u32)

Writes to a virtual config register.

fn generate_acpi_methods(&mut self) -> (Vec<u8>, Option<(u32, MemoryMapping)>)

Construct customized acpi method, and return the AML code and shared memory

fn set_gpe(&mut self, _resources: &mut SystemAllocator) -> Option<u32>

fn get_removed_children_devices(&self) -> Vec<PciAddress>

Get the removed children devices under pci bridge

fn get_new_pci_bus(&self) -> Option<Arc<Mutex<PciBus>>>

Get the pci bus generated by this pci device

fn configure_bridge_window( &mut self, _resources: &mut SystemAllocator, _bar_ranges: &[BarRange] ) -> Result<Vec<BarRange>, Error>

if device is a pci brdige, configure pci bridge window

fn set_subordinate_bus(&mut self, _bus_no: u8)

if device is a pci bridge, configure subordinate bus number

fn supports_iommu(&self) -> bool

Indicates whether the device supports IOMMU

fn set_iommu(&mut self, _iommu: IpcMemoryMapper) -> Result<()>

Sets the IOMMU for the device if supports_iommu()

impl Suspendable for VirtioPciDevice

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.

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.