External/cloud-hypervisor
1
0
Fork 0
mirror of https://github.com/cloud-hypervisor/cloud-hypervisor.git synced 2024-07-16 06:07:15 +00:00
Code Issues Packages Projects Releases Wiki Activity

vmm: device_manager: Get VmFd from AddressManager

Browse Source 
A reference to the VmFd is stored on the AddressManager so it is not
necessary to pass in the VmInfo into all methods that need it as it can
be obtained from the AddressManager.

Signed-off-by: Rob Bradford <robert.bradford@intel.com>
This commit is contained in:
Rob Bradford 2020-01-31 16:07:08 +00:00
parent 6411c3ae42
commit 07bc292fa5
1 changed files with 13 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
vmm/src/device_manager.rs
View File

@ -260,7 +260,6 @@ struct AddressManager {
allocator: Arc<Mutex<SystemAllocator>>, allocator: Arc<Mutex<SystemAllocator>>,
io_bus: Arc<devices::Bus>, io_bus: Arc<devices::Bus>,
mmio_bus: Arc<devices::Bus>, mmio_bus: Arc<devices::Bus>,
#[cfg(feature = "pci_support")]
vm_fd: Arc<VmFd>, vm_fd: Arc<VmFd>,
} }
@ -419,7 +418,6 @@ impl DeviceManager {
allocator, allocator,
io_bus: Arc::new(io_bus), io_bus: Arc::new(io_bus),
mmio_bus: Arc::new(mmio_bus), mmio_bus: Arc::new(mmio_bus),
#[cfg(feature = "pci_support")]
vm_fd: vm_info.vm_fd.clone(), vm_fd: vm_info.vm_fd.clone(),
}); });
@ -509,9 +507,9 @@ impl DeviceManager {
virtio_devices.append(&mut device_manager.make_virtio_devices()?); virtio_devices.append(&mut device_manager.make_virtio_devices()?);
if cfg!(feature = "pci_support") { if cfg!(feature = "pci_support") {
device_manager.add_pci_devices(vm_info, virtio_devices, &interrupt_manager)?; device_manager.add_pci_devices(virtio_devices, &interrupt_manager)?;
} else if cfg!(feature = "mmio_support") { } else if cfg!(feature = "mmio_support") {
device_manager.add_mmio_devices(vm_info, virtio_devices, &interrupt_manager)?; device_manager.add_mmio_devices(virtio_devices, &interrupt_manager)?;
} }
Ok(device_manager) Ok(device_manager)
@ -520,7 +518,6 @@ impl DeviceManager {
#[allow(unused_variables)] #[allow(unused_variables)]
fn add_pci_devices( fn add_pci_devices(
&mut self, &mut self,
vm_info: &VmInfo,
virtio_devices: Vec<(Arc<Mutex<dyn vm_virtio::VirtioDevice>>, bool)>, virtio_devices: Vec<(Arc<Mutex<dyn vm_virtio::VirtioDevice>>, bool)>,
interrupt_manager: &Arc<dyn InterruptManager>, interrupt_manager: &Arc<dyn InterruptManager>,
) -> DeviceManagerResult<()> { ) -> DeviceManagerResult<()> {
@ -549,13 +546,8 @@ impl DeviceManager {
&None &None
}; };
let virtio_iommu_attach_dev = self.add_virtio_pci_device( let virtio_iommu_attach_dev =
device, self.add_virtio_pci_device(device, &mut pci_bus, mapping, interrupt_manager)?;
vm_info.vm_fd,
&mut pci_bus,
mapping,
interrupt_manager,
)?;
if let Some(dev_id) = virtio_iommu_attach_dev { if let Some(dev_id) = virtio_iommu_attach_dev {
iommu_attached_devices.push(dev_id); iommu_attached_devices.push(dev_id);
@ -563,7 +555,7 @@ impl DeviceManager {
} }
let mut vfio_iommu_device_ids = let mut vfio_iommu_device_ids =
self.add_vfio_devices(vm_info, &mut pci_bus, &mut iommu_device, interrupt_manager)?; self.add_vfio_devices(&mut pci_bus, &mut iommu_device, interrupt_manager)?;
iommu_attached_devices.append(&mut vfio_iommu_device_ids); iommu_attached_devices.append(&mut vfio_iommu_device_ids);
@ -575,7 +567,6 @@ impl DeviceManager {
// b/d/f won't match the virtio-iommu device as expected. // b/d/f won't match the virtio-iommu device as expected.
self.add_virtio_pci_device( self.add_virtio_pci_device(
Arc::new(Mutex::new(iommu_device)), Arc::new(Mutex::new(iommu_device)),
vm_info.vm_fd,
&mut pci_bus, &mut pci_bus,
&None, &None,
interrupt_manager, interrupt_manager,
@ -605,7 +596,6 @@ impl DeviceManager {
#[allow(unused_variables, unused_mut)] #[allow(unused_variables, unused_mut)]
fn add_mmio_devices( fn add_mmio_devices(
&mut self, &mut self,
vm_info: &VmInfo,
virtio_devices: Vec<(Arc<Mutex<dyn vm_virtio::VirtioDevice>>, bool)>, virtio_devices: Vec<(Arc<Mutex<dyn vm_virtio::VirtioDevice>>, bool)>,
interrupt_manager: &Arc<dyn InterruptManager>, interrupt_manager: &Arc<dyn InterruptManager>,
) -> DeviceManagerResult<()> { ) -> DeviceManagerResult<()> {
@ -619,7 +609,7 @@ impl DeviceManager {
.unwrap() .unwrap()
.allocate_mmio_addresses(None, MMIO_LEN, Some(MMIO_LEN)); .allocate_mmio_addresses(None, MMIO_LEN, Some(MMIO_LEN));
if let Some(addr) = mmio_addr { if let Some(addr) = mmio_addr {
self.add_virtio_mmio_device(device, vm_info.vm_fd, interrupt_manager, addr)?; self.add_virtio_mmio_device(device, interrupt_manager, addr)?;
} else { } else {
error!("Unable to allocate MMIO address!"); error!("Unable to allocate MMIO address!");
} }
@ -1280,7 +1270,6 @@ impl DeviceManager {
#[cfg(feature = "pci_support")] #[cfg(feature = "pci_support")]
fn add_vfio_devices( fn add_vfio_devices(
&mut self, &mut self,
vm_info: &VmInfo,
pci: &mut PciBus, pci: &mut PciBus,
iommu_device: &mut Option<vm_virtio::Iommu>, iommu_device: &mut Option<vm_virtio::Iommu>,
interrupt_manager: &Arc<dyn InterruptManager>, interrupt_manager: &Arc<dyn InterruptManager>,
@ -1294,7 +1283,7 @@ impl DeviceManager {
if let Some(device_list_cfg) = &self.config.lock().unwrap().devices { if let Some(device_list_cfg) = &self.config.lock().unwrap().devices {
// Create the KVM VFIO device // Create the KVM VFIO device
let device_fd = DeviceManager::create_kvm_device(vm_info.vm_fd)?; let device_fd = DeviceManager::create_kvm_device(&self.address_manager.vm_fd)?;
let device_fd = Arc::new(device_fd); let device_fd = Arc::new(device_fd);
for device_cfg in device_list_cfg.iter() { for device_cfg in device_list_cfg.iter() {
@ -1327,7 +1316,7 @@ impl DeviceManager {
} }
let mut vfio_pci_device = let mut vfio_pci_device =
VfioPciDevice::new(vm_info.vm_fd, vfio_device, interrupt_manager) VfioPciDevice::new(&self.address_manager.vm_fd, vfio_device, interrupt_manager)
.map_err(DeviceManagerError::VfioPciCreate)?; .map_err(DeviceManagerError::VfioPciCreate)?;
let bars = vfio_pci_device let bars = vfio_pci_device
@ -1335,7 +1324,7 @@ impl DeviceManager {
.map_err(DeviceManagerError::AllocateBars)?; .map_err(DeviceManagerError::AllocateBars)?;
mem_slot = vfio_pci_device mem_slot = vfio_pci_device
.map_mmio_regions(vm_info.vm_fd, mem_slot) .map_mmio_regions(&self.address_manager.vm_fd, mem_slot)
.map_err(DeviceManagerError::VfioMapRegion)?; .map_err(DeviceManagerError::VfioMapRegion)?;
let vfio_pci_device = Arc::new(Mutex::new(vfio_pci_device)); let vfio_pci_device = Arc::new(Mutex::new(vfio_pci_device));
@ -1359,7 +1348,6 @@ impl DeviceManager {
fn add_virtio_pci_device( fn add_virtio_pci_device(
&mut self, &mut self,
virtio_device: Arc<Mutex<dyn vm_virtio::VirtioDevice>>, virtio_device: Arc<Mutex<dyn vm_virtio::VirtioDevice>>,
vm_fd: &Arc<VmFd>,
pci: &mut PciBus, pci: &mut PciBus,
iommu_mapping: &Option<Arc<IommuMapping>>, iommu_mapping: &Option<Arc<IommuMapping>>,
interrupt_manager: &Arc<dyn InterruptManager>, interrupt_manager: &Arc<dyn InterruptManager>,
@ -1414,7 +1402,8 @@ impl DeviceManager {
let bar_addr = virtio_pci_device.config_bar_addr(); let bar_addr = virtio_pci_device.config_bar_addr();
for (event, addr) in virtio_pci_device.ioeventfds(bar_addr) { for (event, addr) in virtio_pci_device.ioeventfds(bar_addr) {
let io_addr = IoEventAddress::Mmio(addr); let io_addr = IoEventAddress::Mmio(addr);
vm_fd self.address_manager
.vm_fd
.register_ioevent(event, &io_addr, NoDatamatch) .register_ioevent(event, &io_addr, NoDatamatch)
.map_err(DeviceManagerError::RegisterIoevent)?; .map_err(DeviceManagerError::RegisterIoevent)?;
} }
@ -1448,7 +1437,6 @@ impl DeviceManager {
fn add_virtio_mmio_device( fn add_virtio_mmio_device(
&mut self, &mut self,
virtio_device: Arc<Mutex<dyn vm_virtio::VirtioDevice>>, virtio_device: Arc<Mutex<dyn vm_virtio::VirtioDevice>>,
vm_fd: &Arc<VmFd>,
interrupt_manager: &Arc<dyn InterruptManager>, interrupt_manager: &Arc<dyn InterruptManager>,
mmio_base: GuestAddress, mmio_base: GuestAddress,
) -> DeviceManagerResult<()> { ) -> DeviceManagerResult<()> {
@ -1458,7 +1446,8 @@ impl DeviceManager {
for (i, (event, addr)) in mmio_device.ioeventfds(mmio_base.0).iter().enumerate() { for (i, (event, addr)) in mmio_device.ioeventfds(mmio_base.0).iter().enumerate() {
let io_addr = IoEventAddress::Mmio(*addr); let io_addr = IoEventAddress::Mmio(*addr);
vm_fd self.address_manager
.vm_fd
.register_ioevent(event, &io_addr, i as u32) .register_ioevent(event, &io_addr, i as u32)
.map_err(DeviceManagerError::RegisterIoevent)?; .map_err(DeviceManagerError::RegisterIoevent)?;
} }