Fix: Mark ramdisk frames as used in memory map

common/src/legacy_memory_region.rs

@@ -112,9 +112,12 @@ where
         regions: &mut [MaybeUninit<MemoryRegion>],
         kernel_slice_start: PhysAddr,
         kernel_slice_len: u64,
+        ramdisk_slice_start: Option<PhysAddr>,
+        ramdisk_slice_len: u64,
     ) -> &mut [MemoryRegion] {
         let mut next_index = 0;
         let kernel_slice_start = kernel_slice_start.as_u64();
+        let ramdisk_slice_start = ramdisk_slice_start.map(|a| a.as_u64());
 
         for descriptor in self.original {
             let mut start = descriptor.start();
@@ -157,8 +160,9 @@ where
                 kind,
             };
 
-            // check if region overlaps with kernel
+            // check if region overlaps with kernel or ramdisk
             let kernel_slice_end = kernel_slice_start + kernel_slice_len;
+            let ramdisk_slice_end = ramdisk_slice_start.map(|s| s + ramdisk_slice_len);
             if region.kind == MemoryRegionKind::Usable
                 && kernel_slice_start < region.end
                 && kernel_slice_end > region.start
@@ -198,6 +202,47 @@ where
                 Self::add_region(before_kernel, regions, &mut next_index);
                 Self::add_region(kernel, regions, &mut next_index);
                 Self::add_region(after_kernel, regions, &mut next_index);
+            } else if region.kind == MemoryRegionKind::Usable
+                && ramdisk_slice_start.map(|s| s < region.end).unwrap_or(false)
+                && ramdisk_slice_end.map(|e| e > region.start).unwrap_or(false)
+            {
+                // region overlaps with ramdisk -> we might need to split it
+                let ramdisk_slice_start = ramdisk_slice_start.unwrap();
+                let ramdisk_slice_end = ramdisk_slice_end.unwrap();
+
+                // ensure that the ramdisk allocation does not span multiple regions
+                assert!(
+                    ramdisk_slice_start >= region.start,
+                    "region overlaps with ramdisk, but ramdisk begins before region \
+                (ramdisk_start: {ramdisk_slice_start:#x}, region_start: {:#x})",
+                    region.start
+                );
+                assert!(
+                    ramdisk_slice_end <= region.end,
+                    "region overlaps with ramdisk, but region ends before ramdisk \
+                (ramdisk_end: {ramdisk_slice_end:#x}, region_end: {:#x})",
+                    region.end,
+                );
+
+                // split the region into three parts
+                let before_ramdisk = MemoryRegion {
+                    end: ramdisk_slice_start,
+                    ..region
+                };
+                let ramdisk = MemoryRegion {
+                    start: ramdisk_slice_start,
+                    end: ramdisk_slice_end,
+                    kind: MemoryRegionKind::Bootloader,
+                };
+                let after_ramdisk = MemoryRegion {
+                    start: ramdisk_slice_end,
+                    ..region
+                };
+
+                // add the three regions (empty regions are ignored in `add_region`)
+                Self::add_region(before_ramdisk, regions, &mut next_index);
+                Self::add_region(ramdisk, regions, &mut next_index);
+                Self::add_region(after_ramdisk, regions, &mut next_index);
             } else {
                 // add the region normally
                 Self::add_region(region, regions, &mut next_index);

common/src/lib.rs

@@ -293,14 +293,14 @@ where
         None
     };
     let ramdisk_slice_len = system_info.ramdisk_len;
-    let ramdisk_slice_start = if let Some(ramdisk_address) = system_info.ramdisk_addr {
+    let ramdisk_slice_phys_start = system_info.ramdisk_addr.map(PhysAddr::new);
+    let ramdisk_slice_start = if let Some(physical_address) = ramdisk_slice_phys_start {
         let start_page = mapping_addr_page_aligned(
             config.mappings.ramdisk_memory,
             system_info.ramdisk_len,
             &mut used_entries,
             "ramdisk start",
         );
-        let physical_address = PhysAddr::new(ramdisk_address);
         let ramdisk_physical_start_page: PhysFrame<Size4KiB> =
             PhysFrame::containing_address(physical_address);
         let ramdisk_page_count = (system_info.ramdisk_len - 1) / Size4KiB::SIZE;
@@ -404,6 +404,7 @@ where
         kernel_slice_len,
         kernel_image_offset,
 
+        ramdisk_slice_phys_start,
         ramdisk_slice_start,
         ramdisk_slice_len,
     }
@@ -433,6 +434,7 @@ pub struct Mappings {
     pub kernel_slice_len: u64,
     /// Relocation offset of the kernel image in virtual memory.
     pub kernel_image_offset: VirtAddr,
+    pub ramdisk_slice_phys_start: Option<PhysAddr>,
     pub ramdisk_slice_start: Option<VirtAddr>,
     pub ramdisk_slice_len: u64,
 }
@@ -516,6 +518,8 @@ where
         memory_regions,
         mappings.kernel_slice_start,
         mappings.kernel_slice_len,
+        mappings.ramdisk_slice_phys_start,
+        mappings.ramdisk_slice_len,
     );
 
     log::info!("Create bootinfo");