Remove used_slice concept from LegacyFrameAllocator

Author: Wasabi375

bios/common/src/lib.rs

@@ -5,7 +5,6 @@ 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,10 +145,6 @@ 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,8 +4,7 @@
 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, Region};
-use bootloader_x86_64_common::legacy_memory_region::UsedMemorySlice;
+use bootloader_x86_64_bios_common::{BiosFramebufferInfo, BiosInfo, E820MemoryRegion};
 use bootloader_x86_64_common::RawFrameBufferInfo;
 use bootloader_x86_64_common::{
     legacy_memory_region::LegacyFrameAllocator, load_and_switch_to_kernel, Kernel, PageTables,
@@ -56,10 +55,9 @@ 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_with_used_slices(
+    let mut frame_allocator = LegacyFrameAllocator::new_starting_at(
         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
@@ -218,14 +216,6 @@ fn init_logger(
     framebuffer_info
 }
 
-fn used_memory_slices(info: &BiosInfo) -> impl Iterator<Item = UsedMemorySlice> + Clone {
-    // 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::new_from_len(region.start, 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

@@ -48,19 +48,18 @@ 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, S> {
+pub struct LegacyFrameAllocator<I, D> {
     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 = 0x10_0000;
 
-impl<I, D> LegacyFrameAllocator<I, D, Empty<UsedMemorySlice>>
+impl<I, D> LegacyFrameAllocator<I, D>
 where
     I: ExactSizeIterator<Item = D> + Clone,
     I::Item: LegacyMemoryRegion,
@@ -82,28 +81,16 @@ 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> + Clone,
-{
-    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(start_frame, lower_mem_end);
+        let frame = core::cmp::max(frame, lower_mem_end);
         Self {
             original: memory_map.clone(),
             memory_map,
             current_descriptor: None,
             next_frame: frame,
             min_frame: frame,
-            used_slices,
         }
     }
 
@@ -154,10 +141,10 @@ where
 
     /// Calculate the maximum number of regions produced by [Self::construct_memory_map]
     pub fn memory_map_max_region_count(&self) -> usize {
-        // every used slice can split an original region into 3 new regions,
-        // this means we need to reserve 2 extra spaces for each slice.
-        // There are 3 additional slices (kernel, ramdisk and the bootloader heap)
-        self.len() + (3 + self.used_slices.clone().count()) * 2
+        // every used region can split an original region into 3 new regions,
+        // this means we need to reserve 2 extra spaces for each region.
+        // There are 3 used regions: kernel, ramdisk and the bootloader heap
+        self.len() + 6
     }
 
     /// Converts this type to a boot info memory map.
@@ -174,15 +161,22 @@ where
         ramdisk_slice_start: Option<PhysAddr>,
         ramdisk_slice_len: u64,
     ) -> &mut [MemoryRegion] {
-        let used_slices = Self::used_regions_iter(
-            self.min_frame,
-            self.next_frame,
-            kernel_slice_start,
-            kernel_slice_len,
-            ramdisk_slice_start,
-            ramdisk_slice_len,
-            self.used_slices,
-        );
+        let used_slices = [
+            UsedMemorySlice {
+                start: self.min_frame.start_address().as_u64(),
+                end: self.next_frame.start_address().as_u64(),
+            },
+            UsedMemorySlice::new_from_len(kernel_slice_start.as_u64(), kernel_slice_len),
+        ]
+        .into_iter()
+        .chain(
+            ramdisk_slice_start
+                .map(|start| UsedMemorySlice::new_from_len(start.as_u64(), ramdisk_slice_len)),
+        )
+        .map(|slice| UsedMemorySlice {
+            start: align_down(slice.start, 0x1000),
+            end: align_up(slice.end, 0x1000),
+        });
 
         let mut next_index = 0;
         for descriptor in self.original {
@@ -219,34 +213,6 @@ where
         }
     }
 
-    fn used_regions_iter(
-        min_frame: PhysFrame,
-        next_free: PhysFrame,
-        kernel_slice_start: PhysAddr,
-        kernel_slice_len: u64,
-        ramdisk_slice_start: Option<PhysAddr>,
-        ramdisk_slice_len: u64,
-        used_slices: S,
-    ) -> impl Iterator<Item = UsedMemorySlice> + Clone {
-        [
-            UsedMemorySlice {
-                start: min_frame.start_address().as_u64(),
-                end: next_free.start_address().as_u64(),
-            },
-            UsedMemorySlice::new_from_len(kernel_slice_start.as_u64(), kernel_slice_len),
-        ]
-        .into_iter()
-        .chain(
-            ramdisk_slice_start
-                .map(|start| UsedMemorySlice::new_from_len(start.as_u64(), ramdisk_slice_len)),
-        )
-        .chain(used_slices)
-        .map(|slice| UsedMemorySlice {
-            start: align_down(slice.start, 0x1000),
-            end: align_up(slice.end, 0x1000),
-        })
-    }
-
     fn split_and_add_region<'a, U>(
         mut region: MemoryRegion,
         regions: &mut [MaybeUninit<MemoryRegion>],
@@ -325,11 +291,10 @@ where
     }
 }
 
-unsafe impl<I, D, S> FrameAllocator<Size4KiB> for LegacyFrameAllocator<I, D, S>
+unsafe impl<I, D> FrameAllocator<Size4KiB> for LegacyFrameAllocator<I, D>
 where
     I: ExactSizeIterator<Item = D> + Clone,
     I::Item: LegacyMemoryRegion,
-    S: Iterator<Item = UsedMemorySlice> + Clone,
 {
     fn allocate_frame(&mut self) -> Option<PhysFrame<Size4KiB>> {
         if let Some(current_descriptor) = self.current_descriptor {

common/src/lib.rs

@@ -10,7 +10,6 @@ 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::{
@@ -124,17 +123,16 @@ 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, S>(
+pub fn load_and_switch_to_kernel<I, D>(
     kernel: Kernel,
     boot_config: BootConfig,
-    mut frame_allocator: LegacyFrameAllocator<I, D, S>,
+    mut frame_allocator: LegacyFrameAllocator<I, D>,
     mut page_tables: PageTables,
     system_info: SystemInfo,
 ) -> !
 where
     I: ExactSizeIterator<Item = D> + Clone,
     D: LegacyMemoryRegion,
-    S: Iterator<Item = UsedMemorySlice> + Clone,
 {
     let config = kernel.config;
     let mut mappings = set_up_mappings(
@@ -170,9 +168,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, S>(
+pub fn set_up_mappings<I, D>(
     kernel: Kernel,
-    frame_allocator: &mut LegacyFrameAllocator<I, D, S>,
+    frame_allocator: &mut LegacyFrameAllocator<I, D>,
     page_tables: &mut PageTables,
     framebuffer: Option<&RawFrameBufferInfo>,
     config: &BootloaderConfig,
@@ -181,7 +179,6 @@ pub fn set_up_mappings<I, D, S>(
 where
     I: ExactSizeIterator<Item = D> + Clone,
     D: LegacyMemoryRegion,
-    S: Iterator<Item = UsedMemorySlice> + Clone,
 {
     let kernel_page_table = &mut page_tables.kernel;
 
@@ -469,18 +466,17 @@ 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, S>(
+pub fn create_boot_info<I, D>(
     config: &BootloaderConfig,
     boot_config: &BootConfig,
-    mut frame_allocator: LegacyFrameAllocator<I, D, S>,
+    mut frame_allocator: LegacyFrameAllocator<I, D>,
     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> + Clone,
 {
     log::info!("Allocate bootinfo");