diff --git a/src/arch/src/aarch64/layout.rs b/src/arch/src/aarch64/layout.rs index e258a7ef4..401925d6e 100644 --- a/src/arch/src/aarch64/layout.rs +++ b/src/arch/src/aarch64/layout.rs @@ -49,12 +49,14 @@ // // Taken from (http://infocenter.arm.com/help/topic/com.arm.doc.den0001c/DEN0001C_principles_of_arm_memory_maps.pdf). -/// Start of RAM on 64 bit ARM. -pub const DRAM_MEM_START: u64 = 0x4000_0000; // 1 GB. +/// Start of RAM on 64 bit ARM when loading an EFI firmware. +pub const DRAM_MEM_START_EFI: u64 = 0x4000_0000; // 1 GB. +/// Start of RAM on 64 bit ARM when loading a kernel. +pub const DRAM_MEM_START_KERNEL: u64 = 0x8000_0000; // 2 GB. /// The maximum addressable RAM address. pub const DRAM_MEM_END: u64 = 0x00FF_8000_0000; // 1024 - 2 = 1022 GB. /// The maximum RAM size. -pub const DRAM_MEM_MAX_SIZE: u64 = DRAM_MEM_END - DRAM_MEM_START; +pub const DRAM_MEM_MAX_SIZE: u64 = DRAM_MEM_END - DRAM_MEM_START_KERNEL; /// Kernel command line maximum size. /// As per `arch/arm64/include/uapi/asm/setup.h`. diff --git a/src/arch/src/aarch64/linux/regs.rs b/src/arch/src/aarch64/linux/regs.rs index b932c9cc4..1e620b629 100644 --- a/src/arch/src/aarch64/linux/regs.rs +++ b/src/arch/src/aarch64/linux/regs.rs @@ -7,7 +7,8 @@ use std::{mem, mem::offset_of, num::TryFromIntError, result}; -use super::super::get_fdt_addr; +use crate::ArchMemoryInfo; + use kvm_bindings::{ kvm_regs, user_pt_regs, KVM_REG_ARM64, KVM_REG_ARM64_SYSREG, KVM_REG_ARM64_SYSREG_CRM_MASK, KVM_REG_ARM64_SYSREG_CRM_SHIFT, KVM_REG_ARM64_SYSREG_CRN_MASK, KVM_REG_ARM64_SYSREG_CRN_SHIFT, @@ -17,8 +18,6 @@ use kvm_bindings::{ }; use kvm_ioctls::VcpuFd; -use vm_memory::GuestMemoryMmap; - /// Errors thrown while setting aarch64 registers. #[derive(Debug)] pub enum Error { @@ -108,8 +107,13 @@ arm64_sys_reg!(MPIDR_EL1, 3, 0, 0, 0, 5); /// * `vcpu` - Structure for the VCPU that holds the VCPU's fd. /// * `cpu_id` - Index of current vcpu. /// * `boot_ip` - Starting instruction pointer. -/// * `mem` - Reserved DRAM for current VM. -pub fn setup_regs(vcpu: &VcpuFd, cpu_id: u8, boot_ip: u64, mem: &GuestMemoryMmap) -> Result<()> { +/// * `mem_info` - Structure with information about the memory layout. +pub fn setup_regs( + vcpu: &VcpuFd, + cpu_id: u8, + boot_ip: u64, + mem_info: &ArchMemoryInfo, +) -> Result<()> { // Get the register index of the PSTATE (Processor State) register. vcpu.set_one_reg(arm64_core_reg!(pstate), &PSTATE_FAULT_BITS_64.to_le_bytes()) .map_err(Error::SetCoreRegister)?; @@ -123,8 +127,8 @@ pub fn setup_regs(vcpu: &VcpuFd, cpu_id: u8, boot_ip: u64, mem: &GuestMemoryMmap // Last mandatory thing to set -> the address pointing to the FDT (also called DTB). // "The device tree blob (dtb) must be placed on an 8-byte boundary and must // not exceed 2 megabytes in size." -> https://www.kernel.org/doc/Documentation/arm64/booting.txt. - // We are choosing to place it the end of DRAM. See `get_fdt_addr`. - vcpu.set_one_reg(arm64_core_reg!(regs), &get_fdt_addr(mem).to_le_bytes()) + // For direct kernel boot, we place it at the end of DRAM. + vcpu.set_one_reg(arm64_core_reg!(regs), &mem_info.fdt_addr.to_le_bytes()) .map_err(Error::SetCoreRegister)?; } Ok(()) diff --git a/src/arch/src/aarch64/mod.rs b/src/arch/src/aarch64/mod.rs index 1a750e4f1..9f347656e 100644 --- a/src/arch/src/aarch64/mod.rs +++ b/src/arch/src/aarch64/mod.rs @@ -17,8 +17,11 @@ pub use self::macos::*; use std::fmt::Debug; -use crate::{aarch64::layout::FIRMWARE_START, ArchMemoryInfo}; -use vm_memory::{Address, GuestAddress, GuestMemory, GuestMemoryMmap}; +use crate::{ + aarch64::layout::{DRAM_MEM_START_EFI, DRAM_MEM_START_KERNEL, FIRMWARE_START}, + ArchMemoryInfo, +}; +use vm_memory::{GuestAddress, GuestMemoryMmap}; use vmm_sys_util::align_upwards; use smbios; @@ -43,78 +46,59 @@ pub fn arch_memory_regions( initrd_size: u64, firmware_size: Option, ) -> (ArchMemoryInfo, Vec<(GuestAddress, usize)>) { + let ram_start_addr = if firmware_size.is_some() { + DRAM_MEM_START_EFI + } else { + DRAM_MEM_START_KERNEL + }; let page_size: usize = unsafe { libc::sysconf(libc::_SC_PAGESIZE).try_into().unwrap() }; let dram_size = align_upwards!(size, page_size); - let ram_last_addr = layout::DRAM_MEM_START + (dram_size as u64); + let ram_last_addr = ram_start_addr + (dram_size as u64); let shm_start_addr = ((ram_last_addr / 0x4000_0000) + 1) * 0x4000_0000; + let fdt_addr = if firmware_size.is_some() { + DRAM_MEM_START_EFI + } else { + ram_last_addr - layout::FDT_MAX_SIZE as u64 + }; let info = ArchMemoryInfo { + ram_start_addr, ram_last_addr, shm_start_addr, page_size, - initrd_addr: ram_last_addr - layout::FDT_MAX_SIZE as u64 - initrd_size, + fdt_addr, + initrd_addr: fdt_addr - initrd_size, firmware_addr: FIRMWARE_START, }; let regions = if let Some(firmware_size) = firmware_size { vec![ // Space for loading the firmware (GuestAddress(0u64), align_upwards!(firmware_size, page_size)), - (GuestAddress(layout::DRAM_MEM_START), dram_size), + (GuestAddress(ram_start_addr), dram_size), ] } else { - vec![(GuestAddress(layout::DRAM_MEM_START), dram_size)] + vec![(GuestAddress(ram_start_addr), dram_size)] }; (info, regions) } /// Configures the system and should be called once per vm before starting vcpu threads. -/// For aarch64, we only setup the FDT. -/// -/// # Arguments -/// -/// * `guest_mem` - The memory to be used by the guest. -/// * `cmdline_cstring` - The kernel commandline. -/// * `vcpu_mpidr` - Array of MPIDR register values per vcpu. -/// * `device_info` - A hashmap containing the attached devices for building FDT device nodes. -/// * `gic_device` - The GIC device. -/// * `initrd` - Information about an optional initrd. +/// For aarch64, we only setup SMBIOS. #[allow(clippy::too_many_arguments)] pub fn configure_system( - _guest_mem: &GuestMemoryMmap, - _smbios_oem_strings: &Option>, + guest_mem: &GuestMemoryMmap, + mem_info: &ArchMemoryInfo, + smbios_oem_strings: &Option>, ) -> super::Result<()> { - smbios::setup_smbios(_guest_mem, layout::SMBIOS_START, _smbios_oem_strings) - .map_err(Error::Smbios)?; - - Ok(()) -} - -/// Returns the memory address where the kernel could be loaded. -pub fn get_kernel_start() -> u64 { - layout::DRAM_MEM_START -} - -/// Returns the memory address where the initrd could be loaded. -pub fn initrd_load_addr(guest_mem: &GuestMemoryMmap, initrd_size: usize) -> super::Result { - match GuestAddress(get_fdt_addr(guest_mem)) - .checked_sub(align_upwards!(initrd_size, super::PAGE_SIZE) as u64) - { - Some(offset) => { - if guest_mem.address_in_range(offset) { - Ok(offset.raw_value()) - } else { - Err(Error::InitrdAddress) - } - } - None => Err(Error::InitrdAddress), + // When booting EFI, RAM starts at 0x4000_0000, while when doing a direct kernel + // boot RAM starts at 0x8000_0000. Only write SMBIOS in the former case. + if mem_info.ram_start_addr < layout::SMBIOS_START { + smbios::setup_smbios(guest_mem, layout::SMBIOS_START, smbios_oem_strings) + .map_err(Error::Smbios)?; } -} -// Auxiliary function to get the address where the device tree blob is loaded. -pub fn get_fdt_addr(_mem: &GuestMemoryMmap) -> u64 { - // Put FDT at the beginning of the DRAM - layout::DRAM_MEM_START + Ok(()) } #[cfg(test)] @@ -125,7 +109,10 @@ mod tests { fn test_regions_lt_1024gb() { let (_mem_info, regions) = arch_memory_regions(1usize << 29, 0); assert_eq!(1, regions.len()); - assert_eq!(GuestAddress(super::layout::DRAM_MEM_START), regions[0].0); + assert_eq!( + GuestAddress(super::layout::DRAM_MEM_START_KERNEL), + regions[0].0 + ); assert_eq!(1usize << 29, regions[0].1); } @@ -133,22 +120,10 @@ mod tests { fn test_regions_gt_1024gb() { let (_mem_info, regions) = arch_memory_regions(1usize << 41, 0); assert_eq!(1, regions.len()); - assert_eq!(GuestAddress(super::layout::DRAM_MEM_START), regions[0].0); + assert_eq!( + GuestAddress(super::layout::DRAM_MEM_START_KERNEL), + regions[0].0 + ); assert_eq!(super::layout::DRAM_MEM_MAX_SIZE, regions[0].1 as u64); } - - #[test] - fn test_get_fdt_addr() { - let (_mem_info, regions) = arch_memory_regions(layout::FDT_MAX_SIZE - 0x1000, 0); - let mem = GuestMemoryMmap::from_ranges(®ions).expect("Cannot initialize memory"); - assert_eq!(get_fdt_addr(&mem), layout::DRAM_MEM_START); - - let (_mem_info, regions) = arch_memory_regions(layout::FDT_MAX_SIZE, 0); - let mem = GuestMemoryMmap::from_ranges(®ions).expect("Cannot initialize memory"); - assert_eq!(get_fdt_addr(&mem), layout::DRAM_MEM_START); - - let (_mem_info, regions) = arch_memory_regions(layout::FDT_MAX_SIZE + 0x1000, 0); - let mem = GuestMemoryMmap::from_ranges(®ions).expect("Cannot initialize memory"); - assert_eq!(get_fdt_addr(&mem), 0x1000 + layout::DRAM_MEM_START); - } } diff --git a/src/arch/src/lib.rs b/src/arch/src/lib.rs index 4ab183b53..10f4de073 100644 --- a/src/arch/src/lib.rs +++ b/src/arch/src/lib.rs @@ -12,9 +12,13 @@ pub struct ArchMemoryInfo { pub ram_below_gap: u64, #[cfg(target_arch = "x86_64")] pub ram_above_gap: u64, + #[cfg(target_arch = "aarch64")] + pub ram_start_addr: u64, pub ram_last_addr: u64, pub shm_start_addr: u64, pub page_size: usize, + #[cfg(target_arch = "aarch64")] + pub fdt_addr: u64, pub initrd_addr: u64, pub firmware_addr: u64, } @@ -25,9 +29,8 @@ pub mod aarch64; #[cfg(target_arch = "aarch64")] pub use aarch64::{ - arch_memory_regions, configure_system, get_kernel_start, initrd_load_addr, - layout::CMDLINE_MAX_SIZE, layout::IRQ_BASE, layout::IRQ_MAX, layout::RESET_VECTOR, Error, - MMIO_MEM_START, + arch_memory_regions, configure_system, layout::CMDLINE_MAX_SIZE, layout::IRQ_BASE, + layout::IRQ_MAX, layout::RESET_VECTOR, Error, MMIO_MEM_START, }; /// Module for riscv64 related functionality. @@ -36,9 +39,8 @@ pub mod riscv64; #[cfg(target_arch = "riscv64")] pub use riscv64::{ - arch_memory_regions, configure_system, get_kernel_start, initrd_load_addr, - layout::CMDLINE_MAX_SIZE, layout::IRQ_BASE, layout::IRQ_MAX, layout::RESET_VECTOR, Error, - MMIO_MEM_START, + arch_memory_regions, configure_system, layout::CMDLINE_MAX_SIZE, layout::IRQ_BASE, + layout::IRQ_MAX, layout::RESET_VECTOR, Error, MMIO_MEM_START, }; /// Module for x86_64 related functionality. @@ -47,9 +49,9 @@ pub mod x86_64; #[cfg(target_arch = "x86_64")] pub use crate::x86_64::{ - arch_memory_regions, configure_system, get_kernel_start, initrd_load_addr, - layout::CMDLINE_MAX_SIZE, layout::FIRMWARE_SIZE, layout::FIRMWARE_START, layout::IRQ_BASE, - layout::IRQ_MAX, layout::MMIO_MEM_START, layout::RESET_VECTOR, Error, + arch_memory_regions, configure_system, layout::CMDLINE_MAX_SIZE, layout::FIRMWARE_SIZE, + layout::FIRMWARE_START, layout::IRQ_BASE, layout::IRQ_MAX, layout::MMIO_MEM_START, + layout::RESET_VECTOR, Error, }; /// Type for returning public functions outcome. diff --git a/src/arch/src/riscv64/mod.rs b/src/arch/src/riscv64/mod.rs index ba47501c2..e76c35720 100644 --- a/src/arch/src/riscv64/mod.rs +++ b/src/arch/src/riscv64/mod.rs @@ -67,27 +67,6 @@ pub fn configure_system( Ok(()) } -/// Returns the memory address where the kernel could be loaded. -pub fn get_kernel_start() -> u64 { - layout::DRAM_MEM_START -} - -/// Returns the memory address where the initrd could be loaded. -pub fn initrd_load_addr(guest_mem: &GuestMemoryMmap, initrd_size: usize) -> super::Result { - match GuestAddress(get_fdt_addr(guest_mem)) - .checked_sub(align_upwards!(initrd_size, super::PAGE_SIZE) as u64) - { - Some(offset) => { - if guest_mem.address_in_range(offset) { - Ok(offset.raw_value()) - } else { - Err(Error::InitrdAddress) - } - } - None => Err(Error::InitrdAddress), - } -} - // Auxiliary function to get the address where the device tree blob is loaded. pub fn get_fdt_addr(_mem: &GuestMemoryMmap) -> u64 { // If the memory allocated is smaller than the size allocated for the FDT, diff --git a/src/arch/src/x86_64/mod.rs b/src/arch/src/x86_64/mod.rs index eaff9960f..7c4b6c83d 100644 --- a/src/arch/src/x86_64/mod.rs +++ b/src/arch/src/x86_64/mod.rs @@ -23,9 +23,7 @@ use crate::x86_64::layout::{FIRMWARE_SIZE, FIRMWARE_START}; use crate::{ArchMemoryInfo, InitrdConfig}; use arch_gen::x86::bootparam::{boot_params, E820_RAM}; use vm_memory::Bytes; -use vm_memory::{ - Address, ByteValued, GuestAddress, GuestMemory, GuestMemoryMmap, GuestMemoryRegion, -}; +use vm_memory::{Address, ByteValued, GuestAddress, GuestMemoryMmap}; use vmm_sys_util::align_upwards; // This is a workaround to the Rust enforcement specifying that any implementation of a foreign @@ -238,27 +236,6 @@ pub fn arch_memory_regions( (info, regions) } -/// Returns the memory address where the kernel could be loaded. -pub fn get_kernel_start() -> u64 { - layout::HIMEM_START -} - -/// Returns the memory address where the initrd could be loaded. -pub fn initrd_load_addr(guest_mem: &GuestMemoryMmap, initrd_size: usize) -> super::Result { - let first_region = guest_mem - .find_region(GuestAddress::new(0)) - .ok_or(Error::InitrdAddress)?; - // It's safe to cast to usize because the size of a region can't be greater than usize. - let lowmem_size = first_region.len() as usize; - - if lowmem_size < initrd_size { - return Err(Error::InitrdAddress); - } - - let align_to_pagesize = |address| address & !(super::PAGE_SIZE - 1); - Ok(align_to_pagesize(lowmem_size - initrd_size) as u64) -} - /// Configures the system and should be called once per vm before starting vcpu threads. /// /// # Arguments diff --git a/src/devices/src/fdt/aarch64.rs b/src/devices/src/fdt/aarch64.rs index 8ef879fb7..35a41141d 100644 --- a/src/devices/src/fdt/aarch64.rs +++ b/src/devices/src/fdt/aarch64.rs @@ -12,7 +12,6 @@ use std::{io, result}; use crate::legacy::gic::GICDevice; use crate::legacy::IrqChip; use crate::DeviceType; -use arch::aarch64::get_fdt_addr; use arch::aarch64::layout::{GTIMER_HYP, GTIMER_PHYS, GTIMER_SEC, GTIMER_VIRT}; use arch::{ArchMemoryInfo, InitrdConfig}; use vm_fdt::{Error as FdtError, FdtWriter}; @@ -112,7 +111,7 @@ pub fn create_fdt( let fdt_final = fdt.finish()?; // Write FDT to memory. - let fdt_address = GuestAddress(get_fdt_addr(guest_mem)); + let fdt_address = GuestAddress(arch_memory_info.fdt_addr); guest_mem .write_slice(fdt_final.as_slice(), fdt_address) .map_err(Error::WriteFDTToMemory)?; @@ -177,10 +176,10 @@ fn create_memory_node( _guest_mem: &GuestMemoryMmap, arch_memory_info: &ArchMemoryInfo, ) -> Result<()> { - let mem_size = arch_memory_info.ram_last_addr - arch::aarch64::layout::DRAM_MEM_START; + let mem_size = arch_memory_info.ram_last_addr - arch_memory_info.ram_start_addr; // See https://github.com/torvalds/linux/blob/master/Documentation/devicetree/booting-without-of.txt#L960 // for an explanation of this. - let mem_reg_prop = generate_prop64(&[arch::aarch64::layout::DRAM_MEM_START, mem_size]); + let mem_reg_prop = generate_prop64(&[arch_memory_info.ram_start_addr, mem_size]); let mem_node = fdt.begin_node("memory")?; fdt.property_string("device_type", "memory")?; diff --git a/src/vmm/src/builder.rs b/src/vmm/src/builder.rs index c9f5ec64d..0b35468d2 100644 --- a/src/vmm/src/builder.rs +++ b/src/vmm/src/builder.rs @@ -160,6 +160,8 @@ pub enum StartMicrovmError { InvalidKernelBundle(vm_memory::mmap::MmapRegionError), /// The kernel command line is invalid. KernelCmdline(String), + /// The kernel doesn't fit into the microVM memory. + KernelDoesNotFit(u64, usize), /// The supplied kernel format is not supported. KernelFormatUnsupported, /// Cannot load command line string. @@ -329,6 +331,10 @@ impl Display for StartMicrovmError { ) } KernelCmdline(ref err) => write!(f, "Invalid kernel command line: {err}"), + KernelDoesNotFit(load_addr, size) => write!( + f, + "The kernel doesn't fit in the microVM memory (load_addr={load_addr}, size={size})" + ), KernelFormatUnsupported => { write!(f, "The supplied kernel format is not supported.") } @@ -844,7 +850,7 @@ pub fn build_microvm( vcpus = create_vcpus_aarch64( &vm, &vcpu_config, - &guest_memory, + &arch_memory_info, payload_config.entry_addr, &exit_evt, ) @@ -889,7 +895,7 @@ pub fn build_microvm( vcpus = create_vcpus_aarch64( &vm, &vcpu_config, - &guest_memory, + &arch_memory_info, payload_config.entry_addr, &exit_evt, vcpu_list.clone(), @@ -1283,6 +1289,12 @@ fn load_payload( let kernel_data = unsafe { std::slice::from_raw_parts(kernel_host_addr as *mut u8, kernel_size) }; + if kernel_guest_addr + kernel_size as u64 > _arch_mem_info.ram_last_addr { + return Err(StartMicrovmError::KernelDoesNotFit( + kernel_guest_addr, + kernel_size, + )); + } guest_mem .write(kernel_data, GuestAddress(kernel_guest_addr)) .unwrap(); @@ -1716,7 +1728,7 @@ fn create_vcpus_x86_64( fn create_vcpus_aarch64( vm: &Vm, vcpu_config: &VcpuConfig, - guest_mem: &GuestMemoryMmap, + mem_info: &ArchMemoryInfo, entry_addr: GuestAddress, exit_evt: &EventFd, ) -> super::Result> { @@ -1729,7 +1741,7 @@ fn create_vcpus_aarch64( ) .map_err(Error::Vcpu)?; - vcpu.configure_aarch64(vm.fd(), guest_mem, entry_addr) + vcpu.configure_aarch64(vm.fd(), mem_info, entry_addr) .map_err(Error::Vcpu)?; vcpus.push(vcpu); @@ -1741,7 +1753,7 @@ fn create_vcpus_aarch64( fn create_vcpus_aarch64( _vm: &Vm, vcpu_config: &VcpuConfig, - guest_mem: &GuestMemoryMmap, + mem_info: &ArchMemoryInfo, entry_addr: GuestAddress, exit_evt: &EventFd, vcpu_list: Arc, @@ -1768,7 +1780,7 @@ fn create_vcpus_aarch64( ) .map_err(Error::Vcpu)?; - vcpu.configure_aarch64(guest_mem).map_err(Error::Vcpu)?; + vcpu.configure_aarch64(mem_info).map_err(Error::Vcpu)?; if let Some(boot_sender) = boot_sender { boot_senders.insert(vcpu.get_mpidr(), boot_sender); diff --git a/src/vmm/src/lib.rs b/src/vmm/src/lib.rs index 94cf481c9..d029ce718 100644 --- a/src/vmm/src/lib.rs +++ b/src/vmm/src/lib.rs @@ -307,16 +307,14 @@ impl Vmm { .map_err(Error::SetupFDT)?; } - #[cfg(all(target_arch = "aarch64", target_os = "linux"))] - { - arch::aarch64::configure_system(&self.guest_memory, _smbios_oem_strings) - .map_err(Error::ConfigureSystem)?; - } - - #[cfg(all(target_arch = "aarch64", target_os = "macos"))] + #[cfg(target_arch = "aarch64")] { - arch::aarch64::configure_system(&self.guest_memory, _smbios_oem_strings) - .map_err(Error::ConfigureSystem)?; + arch::aarch64::configure_system( + &self.guest_memory, + &self.arch_memory_info, + _smbios_oem_strings, + ) + .map_err(Error::ConfigureSystem)?; } #[cfg(target_arch = "riscv64")] diff --git a/src/vmm/src/linux/vstate.rs b/src/vmm/src/linux/vstate.rs index 0948c669b..66b99dc25 100644 --- a/src/vmm/src/linux/vstate.rs +++ b/src/vmm/src/linux/vstate.rs @@ -5,6 +5,8 @@ // Use of this source code is governed by a BSD-style license that can be // found in the THIRD-PARTY file. +#[cfg(target_arch = "aarch64")] +use arch::ArchMemoryInfo; use crossbeam_channel::{unbounded, Receiver, Sender, TryRecvError}; use libc::{c_int, c_void, siginfo_t}; use std::cell::Cell; @@ -1201,7 +1203,7 @@ impl Vcpu { pub fn configure_aarch64( &mut self, vm_fd: &VmFd, - guest_mem: &GuestMemoryMmap, + mem_info: &ArchMemoryInfo, kernel_load_addr: GuestAddress, ) -> Result<()> { let mut kvi: kvm_bindings::kvm_vcpu_init = kvm_bindings::kvm_vcpu_init::default(); @@ -1225,7 +1227,7 @@ impl Vcpu { } self.fd.vcpu_init(&kvi).map_err(Error::VcpuArmInit)?; - arch::aarch64::regs::setup_regs(&self.fd, self.id, kernel_load_addr.raw_value(), guest_mem) + arch::aarch64::regs::setup_regs(&self.fd, self.id, kernel_load_addr.raw_value(), mem_info) .map_err(Error::REGSConfiguration)?; self.mpidr = arch::aarch64::regs::read_mpidr(&self.fd).map_err(Error::REGSConfiguration)?; diff --git a/src/vmm/src/macos/vstate.rs b/src/vmm/src/macos/vstate.rs index 49f07c77f..f4c9ccabf 100644 --- a/src/vmm/src/macos/vstate.rs +++ b/src/vmm/src/macos/vstate.rs @@ -18,6 +18,7 @@ use std::time::Duration; use super::super::{FC_EXIT_CODE_GENERIC_ERROR, FC_EXIT_CODE_OK}; use crate::vmm_config::machine_config::CpuFeaturesTemplate; +use arch::ArchMemoryInfo; use crossbeam_channel::{unbounded, Receiver, RecvTimeoutError, Sender}; use devices::legacy::VcpuList; use hvf::{HvfVcpu, HvfVm, VcpuExit, Vcpus}; @@ -320,8 +321,8 @@ impl Vcpu { /// # Arguments /// /// * `guest_mem` - The guest memory used by this microvm. - pub fn configure_aarch64(&mut self, guest_mem: &GuestMemoryMmap) -> Result<()> { - self.fdt_addr = arch::aarch64::get_fdt_addr(guest_mem); + pub fn configure_aarch64(&mut self, mem_info: &ArchMemoryInfo) -> Result<()> { + self.fdt_addr = mem_info.fdt_addr; Ok(()) }