arch/aarch64: use different RAM start addresses

EDK2 expects RAM to start at 0x4000_0000, and a while ago we decided to
make this default for both the EFI and non-EFI flavors. The problem with
this approach is that, on aarch64, the Linux kernel expects to be loaded
at 0x8000_0000, meaning that region needs to be covered by RAM.

For large VMs this isn't a problem but for VMs smaller than 1GB, that
region gets uncovered. In theory, we could add another region dedicated
to the kernel at 0x8000_0000 and let the rest of RAM start at
0x4000_0000, but this has two problems:

- We would be using more RAM than what we were configured to.
- It's very hard to find out exactly the size of the kernel region.

So, instead, let's go back to use two different start addresses,
depending on wether we're booting a firmware or a kernel, but let's do
it in a cleaner way, so we don't depend on having an independent flavor.

Fixes: #460

Signed-off-by: Sergio Lopez <slp@redhat.com>

Author: slp

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`.

src/arch/src/aarch64/mod.rs

@@ -17,7 +17,10 @@ pub use self::macos::*;
 
 use std::fmt::Debug;
 
-use crate::{aarch64::layout::FIRMWARE_START, ArchMemoryInfo};
+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;
 
@@ -43,13 +46,23 @@ pub fn arch_memory_regions(
     initrd_size: u64,
     firmware_size: Option<usize>,
 ) -> (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 = ram_last_addr - layout::FDT_MAX_SIZE as u64;
+    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,
@@ -61,10 +74,10 @@ pub fn arch_memory_regions(
         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)
@@ -100,15 +113,21 @@ 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);
     }
 
     #[test]
     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);
     }
 }

src/arch/src/lib.rs

@@ -12,9 +12,12 @@ 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,

src/devices/src/fdt/aarch64.rs

@@ -176,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")?;