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

vmm: device_manager: Use MemoryManager to get guest memory

Browse Source 
The DeviceManager has a reference to the MemoryManager so use that to
get the GuestMemoryMmap rather than the version stored in the VmInfo
struct.

Signed-off-by: Rob Bradford <robert.bradford@intel.com>
This commit is contained in:
Rob Bradford 2020-01-31 11:55:30 +00:00
parent 066fc6c0d1
commit 6411c3ae42
1 changed files with 30 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

73
vmm/src/device_manager.rs
View File

@ -18,7 +18,6 @@ use crate::memory_manager::{Error as MemoryManagerError, MemoryManager};
use crate::vm::VmInfo; use crate::vm::VmInfo;
#[cfg(feature = "acpi")] #[cfg(feature = "acpi")]
use acpi_tables::{aml, aml::Aml}; use acpi_tables::{aml, aml::Aml};
use arc_swap::ArcSwap;
#[cfg(feature = "acpi")] #[cfg(feature = "acpi")]
use arch::layout; use arch::layout;
use arch::layout::{APIC_START, IOAPIC_SIZE, IOAPIC_START}; use arch::layout::{APIC_START, IOAPIC_SIZE, IOAPIC_START};
@ -46,7 +45,7 @@ use vm_device::interrupt::InterruptManager;
use vm_device::interrupt::{InterruptIndex, PIN_IRQ}; use vm_device::interrupt::{InterruptIndex, PIN_IRQ};
use vm_device::{Migratable, MigratableError, Pausable, Snapshotable}; use vm_device::{Migratable, MigratableError, Pausable, Snapshotable};
use vm_memory::guest_memory::FileOffset; use vm_memory::guest_memory::FileOffset;
use vm_memory::{Address, GuestAddress, GuestMemoryMmap, GuestUsize, MmapRegion}; use vm_memory::{Address, GuestAddress, GuestUsize, MmapRegion};
#[cfg(feature = "pci_support")] #[cfg(feature = "pci_support")]
use vm_virtio::transport::VirtioPciDevice; use vm_virtio::transport::VirtioPciDevice;
use vm_virtio::transport::VirtioTransport; use vm_virtio::transport::VirtioTransport;
@ -395,14 +394,14 @@ pub struct DeviceManager {
migratable_devices: Vec<Arc<Mutex<dyn Migratable>>>, migratable_devices: Vec<Arc<Mutex<dyn Migratable>>>,
// Memory Manager // Memory Manager
_memory_manager: Arc<Mutex<MemoryManager>>, memory_manager: Arc<Mutex<MemoryManager>>,
} }
impl DeviceManager { impl DeviceManager {
pub fn new( pub fn new(
vm_info: &VmInfo, vm_info: &VmInfo,
allocator: Arc<Mutex<SystemAllocator>>, allocator: Arc<Mutex<SystemAllocator>>,
_memory_manager: Arc<Mutex<MemoryManager>>, memory_manager: Arc<Mutex<MemoryManager>>,
_exit_evt: &EventFd, _exit_evt: &EventFd,
reset_evt: &EventFd, reset_evt: &EventFd,
) -> DeviceManagerResult<Self> { ) -> DeviceManagerResult<Self> {
@ -475,7 +474,7 @@ impl DeviceManager {
#[cfg(feature = "acpi")] #[cfg(feature = "acpi")]
address_manager address_manager
.io_bus .io_bus
.insert(_memory_manager.clone(), 0xa00, 0x18) .insert(memory_manager.clone(), 0xa00, 0x18)
.map_err(DeviceManagerError::BusError)?; .map_err(DeviceManagerError::BusError)?;
let mut device_manager = DeviceManager { let mut device_manager = DeviceManager {
@ -488,13 +487,11 @@ impl DeviceManager {
ged_notification_device: None, ged_notification_device: None,
config: vm_info.vm_cfg.clone(), config: vm_info.vm_cfg.clone(),
migratable_devices, migratable_devices,
_memory_manager, memory_manager,
}; };
device_manager.add_legacy_devices( device_manager
vm_info, .add_legacy_devices(reset_evt.try_clone().map_err(DeviceManagerError::EventFd)?)?;
reset_evt.try_clone().map_err(DeviceManagerError::EventFd)?,
)?;
#[cfg(feature = "acpi")] #[cfg(feature = "acpi")]
{ {
@ -554,7 +551,6 @@ impl DeviceManager {
let virtio_iommu_attach_dev = self.add_virtio_pci_device( let virtio_iommu_attach_dev = self.add_virtio_pci_device(
device, device,
vm_info.memory,
vm_info.vm_fd, vm_info.vm_fd,
&mut pci_bus, &mut pci_bus,
mapping, mapping,
@ -579,7 +575,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.memory,
vm_info.vm_fd, vm_info.vm_fd,
&mut pci_bus, &mut pci_bus,
&None, &None,
@ -624,13 +619,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( self.add_virtio_mmio_device(device, vm_info.vm_fd, interrupt_manager, addr)?;
device,
vm_info.memory,
vm_info.vm_fd,
interrupt_manager,
addr,
)?;
} else { } else {
error!("Unable to allocate MMIO address!"); error!("Unable to allocate MMIO address!");
} }
@ -712,11 +701,7 @@ impl DeviceManager {
Ok(Some(ged_device)) Ok(Some(ged_device))
} }
fn add_legacy_devices( fn add_legacy_devices(&mut self, reset_evt: EventFd) -> DeviceManagerResult<()> {
&mut self,
_vm_info: &VmInfo,
reset_evt: EventFd,
) -> DeviceManagerResult<()> {
// Add a shutdown device (i8042) // Add a shutdown device (i8042)
let i8042 = Arc::new(Mutex::new(devices::legacy::I8042Device::new(reset_evt))); let i8042 = Arc::new(Mutex::new(devices::legacy::I8042Device::new(reset_evt)));
@ -728,7 +713,15 @@ impl DeviceManager {
{ {
// Add a CMOS emulated device // Add a CMOS emulated device
use vm_memory::GuestMemory; use vm_memory::GuestMemory;
let mem_size = _vm_info.memory.load().last_addr().0 + 1; let mem_size = self
.memory_manager
.lock()
.unwrap()
.guest_memory()
.load()
.last_addr()
.0
+ 1;
let mem_below_4g = std::cmp::min(arch::layout::MEM_32BIT_RESERVED_START.0, mem_size); let mem_below_4g = std::cmp::min(arch::layout::MEM_32BIT_RESERVED_START.0, mem_size);
let mem_above_4g = mem_size.saturating_sub(arch::layout::RAM_64BIT_START.0); let mem_above_4g = mem_size.saturating_sub(arch::layout::RAM_64BIT_START.0);
@ -1055,7 +1048,7 @@ impl DeviceManager {
self._mmap_regions.push(mmap_region); self._mmap_regions.push(mmap_region);
self._memory_manager self.memory_manager
.lock() .lock()
.unwrap() .unwrap()
.create_userspace_mapping( .create_userspace_mapping(
@ -1152,7 +1145,7 @@ impl DeviceManager {
self._mmap_regions.push(mmap_region); self._mmap_regions.push(mmap_region);
self._memory_manager self.memory_manager
.lock() .lock()
.unwrap() .unwrap()
.create_userspace_mapping( .create_userspace_mapping(
@ -1293,7 +1286,7 @@ impl DeviceManager {
interrupt_manager: &Arc<dyn InterruptManager>, interrupt_manager: &Arc<dyn InterruptManager>,
) -> DeviceManagerResult<Vec<u32>> { ) -> DeviceManagerResult<Vec<u32>> {
let mut mem_slot = self let mut mem_slot = self
._memory_manager .memory_manager
.lock() .lock()
.unwrap() .unwrap()
.allocate_kvm_memory_slot(); .allocate_kvm_memory_slot();
@ -1312,10 +1305,11 @@ impl DeviceManager {
// global device ID. // global device ID.
let device_id = pci.next_device_id() << 3; let device_id = pci.next_device_id() << 3;
let memory = self.memory_manager.lock().unwrap().guest_memory();
let vfio_device = VfioDevice::new( let vfio_device = VfioDevice::new(
&device_cfg.path, &device_cfg.path,
device_fd.clone(), device_fd.clone(),
vm_info.memory.clone(), memory.clone(),
device_cfg.iommu, device_cfg.iommu,
) )
.map_err(DeviceManagerError::VfioCreate)?; .map_err(DeviceManagerError::VfioCreate)?;
@ -1324,7 +1318,7 @@ impl DeviceManager {
if let Some(iommu) = iommu_device { if let Some(iommu) = iommu_device {
let vfio_mapping = Arc::new(VfioDmaMapping::new( let vfio_mapping = Arc::new(VfioDmaMapping::new(
vfio_device.get_container(), vfio_device.get_container(),
Arc::clone(vm_info.memory), memory.clone(),
)); ));
iommu_attached_device_ids.push(device_id); iommu_attached_device_ids.push(device_id);
@ -1362,11 +1356,9 @@ impl DeviceManager {
} }
#[cfg(feature = "pci_support")] #[cfg(feature = "pci_support")]
#[allow(clippy::too_many_arguments)]
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>>,
memory: &Arc<ArcSwap<GuestMemoryMmap>>,
vm_fd: &Arc<VmFd>, vm_fd: &Arc<VmFd>,
pci: &mut PciBus, pci: &mut PciBus,
iommu_mapping: &Option<Arc<IommuMapping>>, iommu_mapping: &Option<Arc<IommuMapping>>,
@ -1404,8 +1396,9 @@ impl DeviceManager {
None None
}; };
let memory = self.memory_manager.lock().unwrap().guest_memory();
let mut virtio_pci_device = VirtioPciDevice::new( let mut virtio_pci_device = VirtioPciDevice::new(
memory.clone(), memory,
virtio_device, virtio_device,
msix_num, msix_num,
iommu_mapping_cb, iommu_mapping_cb,
@ -1451,17 +1444,16 @@ impl DeviceManager {
Ok(ret) Ok(ret)
} }
#[allow(clippy::too_many_arguments)]
#[cfg(feature = "mmio_support")] #[cfg(feature = "mmio_support")]
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>>,
memory: &Arc<ArcSwap<GuestMemoryMmap>>,
vm_fd: &Arc<VmFd>, vm_fd: &Arc<VmFd>,
interrupt_manager: &Arc<dyn InterruptManager>, interrupt_manager: &Arc<dyn InterruptManager>,
mmio_base: GuestAddress, mmio_base: GuestAddress,
) -> DeviceManagerResult<()> { ) -> DeviceManagerResult<()> {
let mut mmio_device = vm_virtio::transport::MmioDevice::new(memory.clone(), virtio_device) let memory = self.memory_manager.lock().unwrap().guest_memory();
let mut mmio_device = vm_virtio::transport::MmioDevice::new(memory, virtio_device)
.map_err(DeviceManagerError::VirtioDevice)?; .map_err(DeviceManagerError::VirtioDevice)?;
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() {
@ -1593,13 +1585,8 @@ fn create_ged_device(ged_irq: u32) -> Vec<u8> {
impl Aml for DeviceManager { impl Aml for DeviceManager {
fn to_aml_bytes(&self) -> Vec<u8> { fn to_aml_bytes(&self) -> Vec<u8> {
let mut bytes = Vec::new(); let mut bytes = Vec::new();
let start_of_device_area = self let start_of_device_area = self.memory_manager.lock().unwrap().start_of_device_area().0;
._memory_manager let end_of_device_area = self.memory_manager.lock().unwrap().end_of_device_area().0;
.lock()
.unwrap()
.start_of_device_area()
.0;
let end_of_device_area = self._memory_manager.lock().unwrap().end_of_device_area().0;
let pci_dsdt_data = aml::Device::new( let pci_dsdt_data = aml::Device::new(
"_SB_.PCI0".into(), "_SB_.PCI0".into(),
vec![ vec![