Record memory slices used by bios

Author: Wasabi375

bios/common/src/lib.rs

@@ -5,6 +5,7 @@ pub mod racy_cell;
 #[cfg_attr(feature = "debug", derive(Debug))]
 #[repr(C)]
 pub struct BiosInfo {
+    pub stage_3: Region,
     pub stage_4: Region,
     pub kernel: Region,
     pub ramdisk: Region,

bios/stage-2/src/main.rs

@@ -145,6 +145,10 @@ fn start(disk_number: u16, partition_table_start: *const u8) -> ! {
     vesa_mode.enable().unwrap();
 
     let mut info = BiosInfo {
+        stage_3: Region {
+            start: STAGE_3_DST as u64,
+            len: stage_3_len,
+        },
         stage_4: Region {
             start: stage_4_dst as u64,
             len: stage_4_len,

bios/stage-4/src/main.rs

@@ -4,7 +4,8 @@
 use crate::memory_descriptor::MemoryRegion;
 use bootloader_api::info::{FrameBufferInfo, PixelFormat};
 use bootloader_boot_config::{BootConfig, LevelFilter};
-use bootloader_x86_64_bios_common::{BiosFramebufferInfo, BiosInfo, E820MemoryRegion};
+use bootloader_x86_64_bios_common::{BiosFramebufferInfo, BiosInfo, E820MemoryRegion, Region};
+use bootloader_x86_64_common::legacy_memory_region::UsedMemorySlice;
 use bootloader_x86_64_common::RawFrameBufferInfo;
 use bootloader_x86_64_common::{
     legacy_memory_region::LegacyFrameAllocator, load_and_switch_to_kernel, Kernel, PageTables,
@@ -55,9 +56,10 @@ pub extern "C" fn _start(info: &mut BiosInfo) -> ! {
     };
     let kernel_size = info.kernel.len;
     let next_free_frame = PhysFrame::containing_address(PhysAddr::new(info.last_used_addr)) + 1;
-    let mut frame_allocator = LegacyFrameAllocator::new_starting_at(
+    let mut frame_allocator = LegacyFrameAllocator::new_with_used_slices(
         next_free_frame,
         memory_map.iter().copied().map(MemoryRegion),
+        used_memory_slices(info),
     );
 
     // We identity-mapped all memory, so the offset between physical and virtual addresses is 0
@@ -216,6 +218,17 @@ fn init_logger(
     framebuffer_info
 }
 
+fn used_memory_slices(info: &BiosInfo) -> impl Iterator<Item = UsedMemorySlice> {
+    // skip kernel and ramdisk because they are handled individually by the
+    // uefi/bios common code
+    [info.stage_3, info.stage_4, info.config_file]
+        .into_iter()
+        .map(|region| UsedMemorySlice {
+            start: PhysAddr::new(region.start),
+            len: region.len,
+        })
+}
+
 /// Creates page table abstraction types for both the bootloader and kernel page tables.
 fn create_page_tables(frame_allocator: &mut impl FrameAllocator<Size4KiB>) -> PageTables {
     // We identity-mapped all memory, so the offset between physical and virtual addresses is 0

common/src/legacy_memory_region.rs

@@ -1,10 +1,23 @@
 use bootloader_api::info::{MemoryRegion, MemoryRegionKind};
-use core::mem::MaybeUninit;
+use core::{
+    iter::{empty, Empty},
+    mem::MaybeUninit,
+};
 use x86_64::{
     structures::paging::{FrameAllocator, PhysFrame, Size4KiB},
     PhysAddr,
 };
 
+/// A slice of memory that is used by the bootloader and needs to be reserved
+/// in the kernel
+#[derive(Clone, Copy, Debug)]
+pub struct UsedMemorySlice {
+    /// the physical start of the slice
+    pub start: PhysAddr,
+    /// the length of the slice
+    pub len: u64,
+}
+
 /// Abstraction trait for a memory region returned by the UEFI or BIOS firmware.
 pub trait LegacyMemoryRegion: Copy + core::fmt::Debug {
     /// Returns the physical start address of the region.
@@ -23,18 +36,19 @@ pub trait LegacyMemoryRegion: Copy + core::fmt::Debug {
 }
 
 /// A physical frame allocator based on a BIOS or UEFI provided memory map.
-pub struct LegacyFrameAllocator<I, D> {
+pub struct LegacyFrameAllocator<I, D, S> {
     original: I,
     memory_map: I,
     current_descriptor: Option<D>,
     next_frame: PhysFrame,
     min_frame: PhysFrame,
+    used_slices: S,
 }
 
 /// Start address of the first frame that is not part of the lower 1MB of frames
 const LOWER_MEMORY_END_PAGE: u64 = 0x100_000;
 
-impl<I, D> LegacyFrameAllocator<I, D>
+impl<I, D> LegacyFrameAllocator<I, D, Empty<UsedMemorySlice>>
 where
     I: ExactSizeIterator<Item = D> + Clone,
     I::Item: LegacyMemoryRegion,
@@ -56,14 +70,28 @@ where
     /// before the given `frame` or `0x10000`(1MB) whichever is higher, there are use cases that require
     /// lower conventional memory access (Such as SMP SIPI).
     pub fn new_starting_at(frame: PhysFrame, memory_map: I) -> Self {
+        Self::new_with_used_slices(frame, memory_map, empty())
+    }
+}
+
+impl<I, D, S> LegacyFrameAllocator<I, D, S>
+where
+    I: ExactSizeIterator<Item = D> + Clone,
+    I::Item: LegacyMemoryRegion,
+    S: Iterator<Item = UsedMemorySlice>,
+{
+    pub fn new_with_used_slices(start_frame: PhysFrame, memory_map: I, used_slices: S) -> Self {
+        // skip frame 0 because the rust core library does not see 0 as a valid address
+        // Also skip at least the lower 1MB of frames, there are use cases that require lower conventional memory access (Such as SMP SIPI).
         let lower_mem_end = PhysFrame::containing_address(PhysAddr::new(LOWER_MEMORY_END_PAGE));
-        let frame = core::cmp::max(frame, lower_mem_end);
+        let frame = core::cmp::max(start_frame, lower_mem_end);
         Self {
             original: memory_map.clone(),
             memory_map,
             current_descriptor: None,
             next_frame: frame,
             min_frame: frame,
+            used_slices,
         }
     }
 
@@ -318,10 +346,11 @@ where
     }
 }
 
-unsafe impl<I, D> FrameAllocator<Size4KiB> for LegacyFrameAllocator<I, D>
+unsafe impl<I, D, S> FrameAllocator<Size4KiB> for LegacyFrameAllocator<I, D, S>
 where
     I: ExactSizeIterator<Item = D> + Clone,
     I::Item: LegacyMemoryRegion,
+    S: Iterator<Item = UsedMemorySlice>,
 {
     fn allocate_frame(&mut self) -> Option<PhysFrame<Size4KiB>> {
         if let Some(current_descriptor) = self.current_descriptor {

common/src/lib.rs

@@ -10,6 +10,7 @@ use bootloader_api::{
 };
 use bootloader_boot_config::{BootConfig, LevelFilter};
 use core::{alloc::Layout, arch::asm, mem::MaybeUninit, slice};
+use legacy_memory_region::UsedMemorySlice;
 use level_4_entries::UsedLevel4Entries;
 use usize_conversions::FromUsize;
 use x86_64::{
@@ -123,16 +124,17 @@ impl<'a> Kernel<'a> {
 /// This function is a convenience function that first calls [`set_up_mappings`], then
 /// [`create_boot_info`], and finally [`switch_to_kernel`]. The given arguments are passed
 /// directly to these functions, so see their docs for more info.
-pub fn load_and_switch_to_kernel<I, D>(
+pub fn load_and_switch_to_kernel<I, D, S>(
     kernel: Kernel,
     boot_config: BootConfig,
-    mut frame_allocator: LegacyFrameAllocator<I, D>,
+    mut frame_allocator: LegacyFrameAllocator<I, D, S>,
     mut page_tables: PageTables,
     system_info: SystemInfo,
 ) -> !
 where
     I: ExactSizeIterator<Item = D> + Clone,
     D: LegacyMemoryRegion,
+    S: Iterator<Item = UsedMemorySlice>,
 {
     let config = kernel.config;
     let mut mappings = set_up_mappings(
@@ -168,9 +170,9 @@ where
 ///
 /// This function reacts to unexpected situations (e.g. invalid kernel ELF file) with a panic, so
 /// errors are not recoverable.
-pub fn set_up_mappings<I, D>(
+pub fn set_up_mappings<I, D, S>(
     kernel: Kernel,
-    frame_allocator: &mut LegacyFrameAllocator<I, D>,
+    frame_allocator: &mut LegacyFrameAllocator<I, D, S>,
     page_tables: &mut PageTables,
     framebuffer: Option<&RawFrameBufferInfo>,
     config: &BootloaderConfig,
@@ -179,6 +181,7 @@ pub fn set_up_mappings<I, D>(
 where
     I: ExactSizeIterator<Item = D> + Clone,
     D: LegacyMemoryRegion,
+    S: Iterator<Item = UsedMemorySlice>,
 {
     let kernel_page_table = &mut page_tables.kernel;
 
@@ -466,17 +469,18 @@ pub struct Mappings {
 /// address space at the same address. This makes it possible to return a Rust
 /// reference that is valid in both address spaces. The necessary physical frames
 /// are taken from the given `frame_allocator`.
-pub fn create_boot_info<I, D>(
+pub fn create_boot_info<I, D, S>(
     config: &BootloaderConfig,
     boot_config: &BootConfig,
-    mut frame_allocator: LegacyFrameAllocator<I, D>,
+    mut frame_allocator: LegacyFrameAllocator<I, D, S>,
     page_tables: &mut PageTables,
     mappings: &mut Mappings,
     system_info: SystemInfo,
 ) -> &'static mut BootInfo
 where
     I: ExactSizeIterator<Item = D> + Clone,
     D: LegacyMemoryRegion,
+    S: Iterator<Item = UsedMemorySlice>,
 {
     log::info!("Allocate bootinfo");