Allocate kernel as normal UEFI loader data

Custom memory kinds are apparently not supported on some architectures.

Author: phil-opp

api/src/info.rs

@@ -145,8 +145,6 @@ pub enum MemoryRegionKind {
     ///
     /// This memory should _not_ be used by the kernel.
     Bootloader,
-    /// Memory mapping of the kernel.
-    Kernel,
     /// An unknown memory region reported by the UEFI firmware.
     ///
     /// Contains the UEFI memory type tag.

common/src/legacy_memory_region.rs

@@ -101,6 +101,8 @@ where
     pub fn construct_memory_map(
         self,
         regions: &mut [MaybeUninit<MemoryRegion>],
+        kernel_slice_start: u64,
+        kernel_slice_len: u64,
     ) -> &mut [MemoryRegion] {
         let mut next_index = 0;
 
@@ -145,7 +147,52 @@ where
                 end: end.as_u64(),
                 kind,
             };
-            Self::add_region(region, regions, &mut next_index).unwrap();
+
+            // check if region overlaps with kernel
+            let kernel_slice_end = kernel_slice_start + kernel_slice_len;
+            if region.kind == MemoryRegionKind::Usable
+                && kernel_slice_start < region.end
+                && kernel_slice_end >= region.start
+            {
+                // region overlaps with kernel -> we might need to split it
+
+                // ensure that the kernel allocation does not span multiple regions
+                assert!(
+                    kernel_slice_start >= region.start,
+                    "region overlaps with kernel, but kernel begins before region \
+                    (kernel_slice_start: {kernel_slice_start:#x}, region_start: {:#x})",
+                    region.start
+                );
+                assert!(
+                    kernel_slice_end <= region.end,
+                    "region overlaps with kernel, but region ends before kernel \
+                    (kernel_slice_end: {kernel_slice_end:#x}, region_end: {:#x})",
+                    region.end,
+                );
+
+                // split the region into three parts
+                let before_kernel = MemoryRegion {
+                    end: kernel_slice_start,
+                    ..region
+                };
+                let kernel = MemoryRegion {
+                    start: kernel_slice_start,
+                    end: kernel_slice_end,
+                    kind: MemoryRegionKind::Bootloader,
+                };
+                let after_kernel = MemoryRegion {
+                    start: kernel_slice_end,
+                    ..region
+                };
+
+                // add the three regions (empty regions are ignored in `add_region`)
+                Self::add_region(before_kernel, regions, &mut next_index).unwrap();
+                Self::add_region(kernel, regions, &mut next_index).unwrap();
+                Self::add_region(after_kernel, regions, &mut next_index).unwrap();
+            } else {
+                // add the region normally
+                Self::add_region(region, regions, &mut next_index).unwrap();
+            }
         }
 
         let initialized = &mut regions[..next_index];
@@ -161,6 +208,10 @@ where
         regions: &mut [MaybeUninit<MemoryRegion>],
         next_index: &mut usize,
     ) -> Result<(), ()> {
+        if region.start == region.end {
+            // skip zero sized regions
+            return Ok(());
+        }
         unsafe {
             regions
                 .get_mut(*next_index)

common/src/lib.rs

@@ -56,6 +56,8 @@ pub struct SystemInfo {
 pub struct Kernel<'a> {
     pub elf: ElfFile<'a>,
     pub config: BootloaderConfig,
+    pub start_address: *const u8,
+    pub len: usize,
 }
 
 impl<'a> Kernel<'a> {
@@ -72,6 +74,8 @@ impl<'a> Kernel<'a> {
         Kernel {
             elf: kernel_elf,
             config,
+            start_address: kernel_slice.as_ptr(),
+            len: kernel_slice.len(),
         }
     }
 }
@@ -151,6 +155,9 @@ where
     enable_write_protect_bit();
 
     let config = kernel.config;
+    let kernel_slice_start = kernel.start_address as u64;
+    let kernel_slice_len = u64::try_from(kernel.len).unwrap();
+
     let (entry_point, tls_template) = load_kernel::load_kernel(
         kernel,
         kernel_page_table,
@@ -313,6 +320,9 @@ where
         physical_memory_offset,
         recursive_index,
         tls_template,
+
+        kernel_slice_start,
+        kernel_slice_len,
     }
 }
 
@@ -333,6 +343,11 @@ pub struct Mappings {
     pub recursive_index: Option<PageTableIndex>,
     /// The thread local storage template of the kernel executable, if it contains one.
     pub tls_template: Option<TlsTemplate>,
+
+    /// Start address of the kernel slice allocation in memory.
+    pub kernel_slice_start: u64,
+    /// Size of the kernel slice allocation in memory.
+    pub kernel_slice_len: u64,
 }
 
 /// Allocates and initializes the boot info struct and the memory map.
@@ -357,7 +372,7 @@ where
     // allocate and map space for the boot info
     let (boot_info, memory_regions) = {
         let boot_info_layout = Layout::new::<BootInfo>();
-        let regions = frame_allocator.len() + 1; // one region might be split into used/unused
+        let regions = frame_allocator.len() + 4; // up to 4 regions might be split into used/unused
         let memory_regions_layout = Layout::array::<MemoryRegion>(regions).unwrap();
         let (combined, memory_regions_offset) =
             boot_info_layout.extend(memory_regions_layout).unwrap();
@@ -412,7 +427,11 @@ where
     log::info!("Create Memory Map");
 
     // build memory map
-    let memory_regions = frame_allocator.construct_memory_map(memory_regions);
+    let memory_regions = frame_allocator.construct_memory_map(
+        memory_regions,
+        mappings.kernel_slice_start,
+        mappings.kernel_slice_len,
+    );
 
     log::info!("Create bootinfo");
 

uefi/src/main.rs

@@ -7,7 +7,6 @@ use crate::memory_descriptor::UefiMemoryDescriptor;
 use bootloader_api::{info::FrameBufferInfo, BootloaderConfig};
 use bootloader_x86_64_common::{legacy_memory_region::LegacyFrameAllocator, Kernel, SystemInfo};
 use core::{arch::asm, cell::UnsafeCell, fmt::Write, mem, panic::PanicInfo, ptr, slice};
-use memory_descriptor::KERNEL_MEMORY_TYPE;
 use uefi::{
     prelude::{entry, Boot, Handle, Status, SystemTable},
     proto::{
@@ -203,7 +202,7 @@ fn load_kernel_file_from_disk(image: Handle, st: &SystemTable<Boot>) -> Option<&
         .boot_services()
         .allocate_pages(
             AllocateType::AnyPages,
-            KERNEL_MEMORY_TYPE,
+            MemoryType::LOADER_DATA,
             ((kernel_size - 1) / 4096) + 1,
         )
         .unwrap() as *mut u8;
@@ -283,7 +282,7 @@ fn load_kernel_file_from_tftp_boot_server(
         .boot_services()
         .allocate_pages(
             AllocateType::AnyPages,
-            KERNEL_MEMORY_TYPE,
+            MemoryType::LOADER_DATA,
             ((kernel_size - 1) / 4096) + 1,
         )
         .expect("Failed to allocate memory for the kernel file") as *mut u8;

uefi/src/memory_descriptor.rs

@@ -7,7 +7,6 @@ use x86_64::PhysAddr;
 pub struct UefiMemoryDescriptor(pub MemoryDescriptor);
 
 const PAGE_SIZE: u64 = 4096;
-pub const KERNEL_MEMORY_TYPE: MemoryType = MemoryType::custom(0x80000000);
 
 impl<'a> LegacyMemoryRegion for UefiMemoryDescriptor {
     fn start(&self) -> PhysAddr {
@@ -21,7 +20,6 @@ impl<'a> LegacyMemoryRegion for UefiMemoryDescriptor {
     fn kind(&self) -> MemoryRegionKind {
         match self.0.ty {
             MemoryType::CONVENTIONAL => MemoryRegionKind::Usable,
-            other if other == KERNEL_MEMORY_TYPE => MemoryRegionKind::Kernel,
             other => MemoryRegionKind::UnknownUefi(other.0),
         }
     }