Struct devices::pci::vfio_pci::VfioPciDevice

pub struct VfioPciDevice {

    device: Arc<VfioDevice>,
    config: VfioPciConfig,
    hotplug: bool,
    hotplug_bus_number: Option<u8>,
    preferred_address: PciAddress,
    pci_address: Option<PciAddress>,
    interrupt_evt: Option<IrqLevelEvent>,
    acpi_notification_evt: Option<Event>,
    mmio_regions: Vec<PciBarConfiguration>,
    io_regions: Vec<PciBarConfiguration>,
    pm_cap: Option<Arc<Mutex<VfioPmCap>>>,
    msi_cap: Option<VfioMsiCap>,
    msix_cap: Option<Arc<Mutex<VfioMsixCap>>>,
    irq_type: Option<VfioIrqType>,
    vm_memory_client: VmMemoryClient,
    device_data: Option<DeviceData>,
    pm_evt: Option<Event>,
    is_in_low_power: Arc<Mutex<bool>>,
    worker_thread: Option<WorkerThread<VfioPciWorker>>,
    vm_socket_vm: Option<Tube>,
    sysfs_path: PathBuf,
    ext_caps: Vec<ExtCap>,
    vcfg_shm_mmap: Option<MemoryMapping>,
    mapped_mmio_bars: BTreeMap<PciBarIndex, (u64, Vec<VmMemoryRegionId>)>,
    activated: bool,
    acpi_notifier_val: Arc<Mutex<Vec<u32>>>,
    gpe: Option<u32>,
    base_class_code: PciClassCode,
}

Implements the Vfio Pci device, then a pci device is added into vm

Fields

device: Arc<VfioDevice>

config: VfioPciConfig

hotplug: bool

hotplug_bus_number: Option<u8>

preferred_address: PciAddress

pci_address: Option<PciAddress>

interrupt_evt: Option<IrqLevelEvent>

acpi_notification_evt: Option<Event>

mmio_regions: Vec<PciBarConfiguration>

io_regions: Vec<PciBarConfiguration>

pm_cap: Option<Arc<Mutex<VfioPmCap>>>

msi_cap: Option<VfioMsiCap>

msix_cap: Option<Arc<Mutex<VfioMsixCap>>>

irq_type: Option<VfioIrqType>

vm_memory_client: VmMemoryClient

device_data: Option<DeviceData>

pm_evt: Option<Event>

is_in_low_power: Arc<Mutex<bool>>

worker_thread: Option<WorkerThread<VfioPciWorker>>

vm_socket_vm: Option<Tube>

sysfs_path: PathBuf

ext_caps: Vec<ExtCap>

vcfg_shm_mmap: Option<MemoryMapping>

mapped_mmio_bars: BTreeMap<PciBarIndex, (u64, Vec<VmMemoryRegionId>)>

activated: bool

acpi_notifier_val: Arc<Mutex<Vec<u32>>>

gpe: Option<u32>

base_class_code: PciClassCode

Implementations

impl VfioPciDevice

pub fn new( sysfs_path: &Path, device: VfioDevice, hotplug: bool, hotplug_bus_number: Option<u8>, guest_address: Option<PciAddress>, vfio_device_socket_msi: Tube, vfio_device_socket_msix: Tube, vm_memory_client: VmMemoryClient, vfio_device_socket_vm: Tube ) -> Result<Self, PciDeviceError>

Constructs a new Vfio Pci device for the give Vfio device

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

Gets the pci address of the device, if one has already been allocated.

pub fn is_gfx(&self) -> bool

fn is_intel_gfx(&self) -> bool

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

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

fn test_acpi_notification(&mut self, val: u32) -> Result<(), PciDeviceError>

fn enable_intx(&mut self)

fn disable_intx(&mut self)

fn disable_irqs(&mut self)

fn enable_msi(&mut self)

fn disable_msi(&mut self)

fn enable_msix(&mut self)

fn disable_msix(&mut self)

fn msix_vectors_update(&self) -> Result<(), VfioError>

fn msix_vector_update(&self, index: usize, irqfd: Option<&Event>)

fn adjust_bar_mmap( &self, bar_mmaps: Vec<vfio_region_sparse_mmap_area>, remove_mmaps: &[AddressRange] ) -> Vec<vfio_region_sparse_mmap_area>

fn remove_bar_mmap_msix( &self, bar_index: PciBarIndex, bar_mmaps: Vec<vfio_region_sparse_mmap_area> ) -> Vec<vfio_region_sparse_mmap_area>

fn add_bar_mmap( &self, index: PciBarIndex, bar_addr: u64 ) -> Vec<VmMemoryRegionId>

fn remove_bar_mmap(&self, mmap_ids: &[VmMemoryRegionId])

fn disable_bars_mmap(&mut self)

fn commit_bars_mmap(&mut self)

fn close(&mut self)

fn start_work_thread(&mut self)

fn collect_bars(&mut self) -> Vec<PciBarConfiguration>

fn configure_barmem(&mut self, bar_info: &PciBarConfiguration, bar_addr: u64)

fn allocate_root_barmem( &mut self, mem_bars: &[PciBarConfiguration], resources: &mut SystemAllocator ) -> Result<Vec<BarRange>, PciDeviceError>

fn allocate_nonroot_barmem( &mut self, mem_bars: &mut [PciBarConfiguration], resources: &mut SystemAllocator ) -> Result<Vec<BarRange>, PciDeviceError>

pub fn get_max_iova(&self) -> u64

Return the supported iova max address of the Vfio Pci device

fn get_ext_cap_by_reg(&self, reg: u32) -> Option<ExtCap>

fn is_skipped_reg(&self, reg: u32) -> bool

Trait Implementations

impl PciDevice for VfioPciDevice

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 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 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 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 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 read_bar(&mut self, bar_index: PciBarIndex, offset: u64, data: &mut [u8])

Reads from a BAR region mapped in to the device.

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

Writes to a BAR region mapped in to the device.

fn destroy_device(&mut self)

Invoked when the device is destroyed

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_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 setup_pci_config_mapping( &mut self, _shmem: &SharedMemory, _base: usize, _len: usize ) -> Result<bool, Error>

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 on_device_sandboxed(&mut self)

Invoked when the device is sandboxed.

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

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()

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

impl Suspendable for VfioPciDevice

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.