External/cloud-hypervisor
1
0
Fork 0
mirror of https://github.com/cloud-hypervisor/cloud-hypervisor.git synced 2024-10-01 11:05:46 +00:00
Code Issues Packages Projects Releases Wiki Activity

vmm: Remove the list of migratable devices

Browse Source 
Now that the device tree fully replaced the need for a dedicated list of
migratable devices, this commit cleans up the codebase by removing it
from the DeviceManager.

Signed-off-by: Sebastien Boeuf <sebastien.boeuf@intel.com>
This commit is contained in:
Sebastien Boeuf 2020-04-30 20:27:19 +02:00
parent 1be7037229
commit b91ab1e3a5
1 changed files with 9 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

67
vmm/src/device_manager.rs
View File

@ -632,9 +632,6 @@ pub struct DeviceManager {
// VM configuration // VM configuration
config: Arc<Mutex<VmConfig>>, config: Arc<Mutex<VmConfig>>,
// Migratable devices
migratable_devices: HashMap<String, Arc<Mutex<dyn Migratable>>>,
// Memory Manager // Memory Manager
memory_manager: Arc<Mutex<MemoryManager>>, memory_manager: Arc<Mutex<MemoryManager>>,
@ -742,7 +739,6 @@ impl DeviceManager {
#[cfg(feature = "acpi")] #[cfg(feature = "acpi")]
ged_notification_device: None, ged_notification_device: None,
config, config,
migratable_devices: HashMap::new(),
memory_manager, memory_manager,
virtio_devices: Vec::new(), virtio_devices: Vec::new(),
bus_devices: Vec::new(), bus_devices: Vec::new(),
@ -871,11 +867,6 @@ impl DeviceManager {
Ok(()) Ok(())
} }
fn add_migratable_device(&mut self, migratable_device: Arc<Mutex<dyn Migratable>>) {
let id = migratable_device.lock().unwrap().id();
self.migratable_devices.insert(id, migratable_device);
}
#[allow(unused_variables)] #[allow(unused_variables)]
fn add_pci_devices( fn add_pci_devices(
&mut self, &mut self,
@ -1033,8 +1024,6 @@ impl DeviceManager {
DeviceNode::new(id, Some(Arc::clone(&ioapic) as Arc<Mutex<dyn Migratable>>)), DeviceNode::new(id, Some(Arc::clone(&ioapic) as Arc<Mutex<dyn Migratable>>)),
); );
self.add_migratable_device(Arc::clone(&ioapic) as Arc<Mutex<dyn Migratable>>);
Ok(ioapic) Ok(ioapic)
} }
@ -1211,8 +1200,6 @@ impl DeviceManager {
DeviceNode::new(id, Some(Arc::clone(&serial) as Arc<Mutex<dyn Migratable>>)), DeviceNode::new(id, Some(Arc::clone(&serial) as Arc<Mutex<dyn Migratable>>)),
); );
self.add_migratable_device(Arc::clone(&serial) as Arc<Mutex<dyn Migratable>>);
Some(serial) Some(serial)
} else { } else {
None None
@ -1254,8 +1241,6 @@ impl DeviceManager {
), ),
); );
self.add_migratable_device(virtio_console_device as Arc<Mutex<dyn Migratable>>);
Some(console_input) Some(console_input)
} else { } else {
None None
@ -1363,10 +1348,6 @@ impl DeviceManager {
), ),
); );
self.add_migratable_device(
Arc::clone(&vhost_user_block_device) as Arc<Mutex<dyn Migratable>>
);
Ok(( Ok((
Arc::clone(&vhost_user_block_device) as VirtioDeviceArc, Arc::clone(&vhost_user_block_device) as VirtioDeviceArc,
false, false,
@ -1424,8 +1405,6 @@ impl DeviceManager {
), ),
); );
self.add_migratable_device(Arc::clone(&block) as Arc<Mutex<dyn Migratable>>);
Ok((Arc::clone(&block) as VirtioDeviceArc, disk_cfg.iommu, id)) Ok((Arc::clone(&block) as VirtioDeviceArc, disk_cfg.iommu, id))
} }
ImageType::Qcow2 => { ImageType::Qcow2 => {
@ -1459,8 +1438,6 @@ impl DeviceManager {
), ),
); );
self.add_migratable_device(Arc::clone(&block) as Arc<Mutex<dyn Migratable>>);
Ok((Arc::clone(&block) as VirtioDeviceArc, disk_cfg.iommu, id)) Ok((Arc::clone(&block) as VirtioDeviceArc, disk_cfg.iommu, id))
} }
} }
@ -1547,9 +1524,6 @@ impl DeviceManager {
), ),
); );
self.add_migratable_device(
Arc::clone(&vhost_user_net_device) as Arc<Mutex<dyn Migratable>>
);
Ok(( Ok((
Arc::clone(&vhost_user_net_device) as VirtioDeviceArc, Arc::clone(&vhost_user_net_device) as VirtioDeviceArc,
net_cfg.iommu, net_cfg.iommu,
@ -1597,7 +1571,6 @@ impl DeviceManager {
), ),
); );
self.add_migratable_device(Arc::clone(&virtio_net_device) as Arc<Mutex<dyn Migratable>>);
Ok(( Ok((
Arc::clone(&virtio_net_device) as VirtioDeviceArc, Arc::clone(&virtio_net_device) as VirtioDeviceArc,
net_cfg.iommu, net_cfg.iommu,
@ -1652,10 +1625,6 @@ impl DeviceManager {
Some(Arc::clone(&virtio_rng_device) as Arc<Mutex<dyn Migratable>>), Some(Arc::clone(&virtio_rng_device) as Arc<Mutex<dyn Migratable>>),
), ),
); );
self.add_migratable_device(
Arc::clone(&virtio_rng_device) as Arc<Mutex<dyn Migratable>>
);
} }
Ok(devices) Ok(devices)
@ -1795,8 +1764,6 @@ impl DeviceManager {
node.migratable = Some(Arc::clone(&virtio_fs_device) as Arc<Mutex<dyn Migratable>>); node.migratable = Some(Arc::clone(&virtio_fs_device) as Arc<Mutex<dyn Migratable>>);
self.device_tree.insert(id.clone(), node); self.device_tree.insert(id.clone(), node);
self.add_migratable_device(Arc::clone(&virtio_fs_device) as Arc<Mutex<dyn Migratable>>);
Ok((Arc::clone(&virtio_fs_device) as VirtioDeviceArc, false, id)) Ok((Arc::clone(&virtio_fs_device) as VirtioDeviceArc, false, id))
} else { } else {
Err(DeviceManagerError::NoVirtioFsSock) Err(DeviceManagerError::NoVirtioFsSock)
@ -1984,8 +1951,6 @@ impl DeviceManager {
node.migratable = Some(Arc::clone(&virtio_pmem_device) as Arc<Mutex<dyn Migratable>>); node.migratable = Some(Arc::clone(&virtio_pmem_device) as Arc<Mutex<dyn Migratable>>);
self.device_tree.insert(id.clone(), node); self.device_tree.insert(id.clone(), node);
self.add_migratable_device(Arc::clone(&virtio_pmem_device) as Arc<Mutex<dyn Migratable>>);
Ok(( Ok((
Arc::clone(&virtio_pmem_device) as VirtioDeviceArc, Arc::clone(&virtio_pmem_device) as VirtioDeviceArc,
pmem_cfg.iommu, pmem_cfg.iommu,
@ -2051,8 +2016,6 @@ impl DeviceManager {
), ),
); );
self.add_migratable_device(Arc::clone(&vsock_device) as Arc<Mutex<dyn Migratable>>);
Ok(( Ok((
Arc::clone(&vsock_device) as VirtioDeviceArc, Arc::clone(&vsock_device) as VirtioDeviceArc,
vsock_cfg.iommu, vsock_cfg.iommu,
@ -2111,8 +2074,6 @@ impl DeviceManager {
Some(Arc::clone(&virtio_mem_device) as Arc<Mutex<dyn Migratable>>), Some(Arc::clone(&virtio_mem_device) as Arc<Mutex<dyn Migratable>>),
), ),
); );
self.add_migratable_device(Arc::clone(&virtio_mem_device) as Arc<Mutex<dyn Migratable>>);
} }
Ok(devices) Ok(devices)
@ -2394,8 +2355,6 @@ impl DeviceManager {
node.migratable = Some(Arc::clone(&virtio_pci_device) as Arc<Mutex<dyn Migratable>>); node.migratable = Some(Arc::clone(&virtio_pci_device) as Arc<Mutex<dyn Migratable>>);
self.device_tree.insert(id, node); self.device_tree.insert(id, node);
self.add_migratable_device(Arc::clone(&virtio_pci_device) as Arc<Mutex<dyn Migratable>>);
Ok(pci_device_bdf) Ok(pci_device_bdf)
} }
@ -2536,8 +2495,6 @@ impl DeviceManager {
node.migratable = Some(Arc::clone(&mmio_device_arc) as Arc<Mutex<dyn Migratable>>); node.migratable = Some(Arc::clone(&mmio_device_arc) as Arc<Mutex<dyn Migratable>>);
self.device_tree.insert(id, node); self.device_tree.insert(id, node);
self.add_migratable_device(Arc::clone(&mmio_device_arc) as Arc<Mutex<dyn Migratable>>);
Ok(()) Ok(())
} }
@ -2714,15 +2671,12 @@ impl DeviceManager {
.map_err(DeviceManagerError::PutPciDeviceId)?; .map_err(DeviceManagerError::PutPciDeviceId)?;
if let Some(any_device) = self.pci_devices.remove(&pci_device_bdf) { if let Some(any_device) = self.pci_devices.remove(&pci_device_bdf) {
let (pci_device, bus_device, migratable_device, virtio_device) = if let Ok( let (pci_device, bus_device, virtio_device) = if let Ok(vfio_pci_device) =
vfio_pci_device,
) =
any_device.clone().downcast::<Mutex<VfioPciDevice>>() any_device.clone().downcast::<Mutex<VfioPciDevice>>()
{ {
( (
Arc::clone(&vfio_pci_device) as Arc<Mutex<dyn PciDevice>>, Arc::clone(&vfio_pci_device) as Arc<Mutex<dyn PciDevice>>,
Arc::clone(&vfio_pci_device) as Arc<Mutex<dyn BusDevice>>, Arc::clone(&vfio_pci_device) as Arc<Mutex<dyn BusDevice>>,
None as Option<Arc<Mutex<dyn Migratable>>>,
None as Option<VirtioDeviceArc>, None as Option<VirtioDeviceArc>,
) )
} else if let Ok(virtio_pci_device) = any_device.downcast::<Mutex<VirtioPciDevice>>() { } else if let Ok(virtio_pci_device) = any_device.downcast::<Mutex<VirtioPciDevice>>() {
@ -2738,7 +2692,6 @@ impl DeviceManager {
( (
Arc::clone(&virtio_pci_device) as Arc<Mutex<dyn PciDevice>>, Arc::clone(&virtio_pci_device) as Arc<Mutex<dyn PciDevice>>,
Arc::clone(&virtio_pci_device) as Arc<Mutex<dyn BusDevice>>, Arc::clone(&virtio_pci_device) as Arc<Mutex<dyn BusDevice>>,
Some(Arc::clone(&virtio_pci_device) as Arc<Mutex<dyn Migratable>>),
Some(virtio_pci_device.lock().unwrap().virtio_device()), Some(virtio_pci_device.lock().unwrap().virtio_device()),
) )
} else { } else {
@ -2773,12 +2726,6 @@ impl DeviceManager {
self.bus_devices self.bus_devices
.retain(|dev| !Arc::ptr_eq(dev, &bus_device)); .retain(|dev| !Arc::ptr_eq(dev, &bus_device));
// Remove the device from the list of Migratable devices.
if let Some(migratable_device) = &migratable_device {
let id = migratable_device.lock().unwrap().id();
self.migratable_devices.retain(|i, _| *i != id);
}
// Shutdown and remove the underlying virtio-device if present // Shutdown and remove the underlying virtio-device if present
if let Some(virtio_device) = virtio_device { if let Some(virtio_device) = virtio_device {
for mapping in virtio_device.lock().unwrap().userspace_mappings() { for mapping in virtio_device.lock().unwrap().userspace_mappings() {
@ -3137,16 +3084,20 @@ impl Aml for DeviceManager {
impl Pausable for DeviceManager { impl Pausable for DeviceManager {
fn pause(&mut self) -> result::Result<(), MigratableError> { fn pause(&mut self) -> result::Result<(), MigratableError> {
for (_, dev) in self.migratable_devices.iter() { for (_, device_node) in self.device_tree.iter() {
dev.lock().unwrap().pause()?; if let Some(migratable) = &device_node.migratable {
migratable.lock().unwrap().pause()?;
}
} }
Ok(()) Ok(())
} }
fn resume(&mut self) -> result::Result<(), MigratableError> { fn resume(&mut self) -> result::Result<(), MigratableError> {
for (_, dev) in self.migratable_devices.iter() { for (_, device_node) in self.device_tree.iter() {
dev.lock().unwrap().resume()?; if let Some(migratable) = &device_node.migratable {
migratable.lock().unwrap().resume()?;
}
} }
Ok(()) Ok(())