Method add_vfio_device

vmm/src/device_manager.rs:3814–4004

(
        &mut self,
        device_cfg: &mut DeviceConfig,
    )

    }

    fn add_vfio_device(
        &mut self,
        device_cfg: &mut DeviceConfig,
    ) -> DeviceManagerResult<(PciBdf, String)> {
        let vfio_name = if let Some(id) = &device_cfg.pci_common.id {
            id.clone()
        } else {
            let id = self.next_device_name(VFIO_DEVICE_NAME_PREFIX)?;
            device_cfg.pci_common.id = Some(id.clone());
            id
        };

        let (pci_segment_id, pci_device_bdf, resources) = self.pci_resources(
            &vfio_name,
            device_cfg.pci_common.pci_segment,
            device_cfg.pci_common.pci_device_id,
        )?;

        let mut needs_dma_mapping = false;

        // Here we create a new VfioOps for two reasons:
        // 1) This is the first VFIO device, meaning we need a new VfioOps
        //    which will be shared with other VFIO devices.
        // 2) The new VFIO device is attached to a vIOMMU, meaning we must
        //    create a dedicated VfioOps. In the vIOMMU use case, we can't
        //    let all devices share the same VfioOps since we couldn't
        //    map/unmap memory for each device independently. That's simply
        //    because the map/unmap operations happen at the VfioOps level.
        //
        // Note: this is a limitation of the legacy VFIO interface using
        // container/group. The VFIO cdev and iommufd do not have such a
        // limitation, and this will be revised once we have VFIO cdev and
        // iommufd support.
        let vfio_ops = if device_cfg.pci_common.iommu {
            let vfio_ops = self.create_vfio_ops()?;

            let vfio_mapping = Arc::new(VfioDmaMapping::new(
                Arc::clone(&vfio_ops),
                Arc::new(self.memory_manager.lock().unwrap().guest_memory()),
                Arc::clone(&self.mmio_regions),
            ));

            if let Some(iommu) = &self.iommu_device {
                iommu
                    .lock()
                    .unwrap()
                    .add_external_mapping(pci_device_bdf.into(), vfio_mapping);
            } else {
                return Err(DeviceManagerError::MissingVirtualIommu);
            }

            vfio_ops
        } else if let Some(vfio_ops) = &self.vfio_ops {
            Arc::clone(vfio_ops)
        } else {
            let vfio_ops = self.create_vfio_ops()?;
            needs_dma_mapping = true;
            self.vfio_ops = Some(Arc::clone(&vfio_ops));