Load E820 memory map and put everything together

Author: phil-opp

bios/common/src/lib.rs

@@ -3,16 +3,18 @@
 pub mod racy_cell;
 
 #[cfg_attr(feature = "debug", derive(Debug))]
-#[derive(Clone, Copy)]
+#[repr(C)]
 pub struct BiosInfo {
     pub stage_4: Region,
     pub kernel: Region,
-    pub memory_map: Region,
     pub framebuffer: FramebufferInfo,
+    pub memory_map_addr: u32,
+    pub memory_map_len: u16,
 }
 
 #[cfg_attr(feature = "debug", derive(Debug))]
 #[derive(Clone, Copy)]
+#[repr(C)]
 pub struct FramebufferInfo {
     pub region: Region,
     pub width: u16,
@@ -24,13 +26,15 @@ pub struct FramebufferInfo {
 
 #[cfg_attr(feature = "debug", derive(Debug))]
 #[derive(Clone, Copy)]
+#[repr(C)]
 pub struct Region {
     pub start: u64,
     pub len: u64,
 }
 
 #[cfg_attr(feature = "debug", derive(Debug))]
 #[derive(Clone, Copy)]
+#[repr(C)]
 pub enum PixelFormat {
     Rgb,
     Bgr,
@@ -40,3 +44,12 @@ pub enum PixelFormat {
         blue_position: u8,
     },
 }
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[repr(C)]
+pub struct E820MemoryRegion {
+    pub start_addr: u64,
+    pub len: u64,
+    pub region_type: u32,
+    pub acpi_extended_attributes: u32,
+}

bios/stage-2/src/main.rs

@@ -16,6 +16,7 @@ use mbr_nostd::{PartitionTableEntry, PartitionType};
 mod dap;
 mod disk;
 mod fat;
+mod memory_map;
 mod protected_mode;
 mod screen;
 mod vesa;
@@ -41,7 +42,11 @@ static mut DISK_BUFFER: AlignedArrayBuffer<0x4000> = AlignedArrayBuffer {
 
 #[no_mangle]
 #[link_section = ".start"]
-pub extern "C" fn _start(disk_number: u16, partition_table_start: *const u8) {
+pub extern "C" fn _start(disk_number: u16, partition_table_start: *const u8) -> ! {
+    start(disk_number, partition_table_start)
+}
+
+fn start(disk_number: u16, partition_table_start: *const u8) -> ! {
     screen::Writer.write_str(" -> SECOND STAGE\n").unwrap();
 
     enter_unreal_mode();
@@ -100,6 +105,9 @@ pub extern "C" fn _start(disk_number: u16, partition_table_start: *const u8) {
     let kernel_len = load_file("kernel-x86_64", KERNEL_DST, &mut fs, &mut disk, disk_buffer);
     writeln!(screen::Writer, "kernel loaded at {KERNEL_DST:#p}").unwrap();
 
+    let memory_map = memory_map::query_memory_map().unwrap();
+    writeln!(screen::Writer, "{memory_map:x?}").unwrap();
+
     let mut vesa_info = vesa::VesaInfo::query(disk_buffer).unwrap();
     let vesa_mode = vesa_info.get_best_mode(1000, 1000).unwrap().unwrap();
     writeln!(
@@ -111,9 +119,7 @@ pub extern "C" fn _start(disk_number: u16, partition_table_start: *const u8) {
     .unwrap();
     vesa_mode.enable().unwrap();
 
-    // TODO: Retrieve memory map
-
-    let info = BiosInfo {
+    let mut info = BiosInfo {
         stage_4: Region {
             start: stage_4_dst as u64,
             len: stage_4_len,
@@ -122,8 +128,8 @@ pub extern "C" fn _start(disk_number: u16, partition_table_start: *const u8) {
             start: KERNEL_DST as u64,
             len: kernel_len,
         },
-        // TODO
-        memory_map: Region { start: 0, len: 0 },
+        memory_map_addr: memory_map.as_mut_ptr() as u32,
+        memory_map_len: memory_map.len().try_into().unwrap(),
         framebuffer: FramebufferInfo {
             region: Region {
                 start: vesa_mode.framebuffer_start.into(),
@@ -137,7 +143,7 @@ pub extern "C" fn _start(disk_number: u16, partition_table_start: *const u8) {
         },
     };
 
-    enter_protected_mode_and_jump_to_stage_3(STAGE_3_DST, &info);
+    enter_protected_mode_and_jump_to_stage_3(STAGE_3_DST, &mut info);
 
     loop {}
 }

bios/stage-2/src/memory_map.rs

@@ -0,0 +1,69 @@
+// From http://wiki.osdev.org/Detecting_Memory_(x86)#Getting_an_E820_Memory_Map
+
+use crate::split_array_ref;
+use bootloader_x86_64_bios_common::{racy_cell::RacyCell, E820MemoryRegion};
+use core::arch::asm;
+
+static MEMORY_MAP: RacyCell<[E820MemoryRegion; 100]> = RacyCell::new(
+    [E820MemoryRegion {
+        start_addr: 0,
+        len: 0,
+        region_type: 0,
+        acpi_extended_attributes: 0,
+    }; 100],
+);
+
+/// use the INT 0x15, eax= 0xE820 BIOS function to get a memory map
+pub fn query_memory_map() -> Result<&'static mut [E820MemoryRegion], ()> {
+    const SMAP: u32 = 0x534D4150;
+
+    let memory_map = unsafe { MEMORY_MAP.get_mut() };
+
+    let mut i = 0;
+
+    let mut offset = 0;
+    let buf = [0u8; 24];
+    loop {
+        let mut ret = 0;
+        let mut buf_written_len = 0;
+        unsafe {
+            asm!(
+                "int 0x15",
+                inout ("eax") 0xe820 => ret,
+                in("edx") SMAP,
+                inout("ebx") offset,
+                inout("ecx") buf.len() => buf_written_len,
+                in("di") &buf
+            )
+        };
+        if ret != SMAP {
+            return Err(());
+        }
+
+        if buf_written_len != 0 {
+            let buf = &buf[..buf_written_len];
+
+            let (&base_raw, rest) = split_array_ref(&buf);
+            let (&len_raw, rest) = split_array_ref(rest);
+            let (&kind_raw, rest) = split_array_ref(rest);
+            let acpi_extended_raw: [u8; 4] = rest.try_into().unwrap_or_default();
+
+            let len = u64::from_ne_bytes(len_raw);
+            if len != 0 {
+                memory_map[i] = E820MemoryRegion {
+                    start_addr: u64::from_ne_bytes(base_raw),
+                    len,
+                    region_type: u32::from_ne_bytes(kind_raw),
+                    acpi_extended_attributes: u32::from_ne_bytes(acpi_extended_raw),
+                };
+                i += 1;
+            }
+        }
+
+        if offset == 0 {
+            break;
+        }
+    }
+
+    Ok(&mut memory_map[..i])
+}

bios/stage-2/src/protected_mode.rs

@@ -104,7 +104,7 @@ pub unsafe fn read_from_protected_mode(ptr: *mut u8) -> u8 {
     res
 }
 
-pub fn enter_protected_mode_and_jump_to_stage_3(entry_point: *const u8, info: &BiosInfo) {
+pub fn enter_protected_mode_and_jump_to_stage_3(entry_point: *const u8, info: &mut BiosInfo) {
     unsafe { asm!("cli") };
     set_protected_mode_bit();
     unsafe {

bios/stage-3/src/main.rs

@@ -12,10 +12,10 @@ mod screen;
 
 #[no_mangle]
 #[link_section = ".start"]
-pub extern "C" fn _start(info: &BiosInfo) {
+pub extern "C" fn _start(info: &mut BiosInfo) {
     screen::init(info.framebuffer);
     // Writer.clear_screen();
-    writeln!(Writer, "Third Stage ({info:#x?})").unwrap();
+    writeln!(Writer, "Third Stage ({info:x?})").unwrap();
 
     // set up identity mapping, enable paging, and switch CPU into long
     // mode (32-bit compatibility mode)
@@ -28,7 +28,7 @@ pub extern "C" fn _start(info: &BiosInfo) {
 }
 
 #[no_mangle]
-pub fn enter_long_mode_and_jump_to_stage_4(info: &BiosInfo) {
+pub fn enter_long_mode_and_jump_to_stage_4(info: &mut BiosInfo) {
     let _ = writeln!(Writer, "Paging init done, jumping to stage 4");
     unsafe {
         asm!(

bios/stage-4/src/main.rs

@@ -1,10 +1,10 @@
 #![no_std]
 #![no_main]
 
-use crate::memory_descriptor::E820MemoryRegion;
+use crate::memory_descriptor::MemoryRegion;
 use crate::screen::Writer;
 use bootloader_api::info::{FrameBufferInfo, PixelFormat};
-use bootloader_x86_64_bios_common::BiosInfo;
+use bootloader_x86_64_bios_common::{BiosInfo, E820MemoryRegion};
 use bootloader_x86_64_common::{
     legacy_memory_region::LegacyFrameAllocator, load_and_switch_to_kernel, logger::LOGGER, Kernel,
     PageTables, SystemInfo,
@@ -28,24 +28,26 @@ mod screen;
 
 #[no_mangle]
 #[link_section = ".start"]
-pub extern "C" fn _start(info: &BiosInfo) -> ! {
+pub extern "C" fn _start(info: &mut BiosInfo) -> ! {
     screen::init(info.framebuffer);
     writeln!(Writer, "4th Stage").unwrap();
     writeln!(Writer, "{info:x?}").unwrap();
 
-    let e820_memory_map = {
-        assert!(info.memory_map.start != 0, "memory map address must be set");
-        let ptr = usize_from(info.memory_map.start) as *const E820MemoryRegion;
-        unsafe {
-            slice::from_raw_parts(
-                ptr,
-                usize_from(info.memory_map.len / size_of::<E820MemoryRegion>() as u64),
-            )
-        }
+    let memory_map: &mut [E820MemoryRegion] = unsafe {
+        core::slice::from_raw_parts_mut(
+            info.memory_map_addr as *mut _,
+            info.memory_map_len.try_into().unwrap(),
+        )
     };
-    let max_phys_addr = e820_memory_map
+
+    memory_map.sort_unstable_by_key(|e| e.start_addr);
+
+    let max_phys_addr = memory_map
         .iter()
-        .map(|r| r.start_addr + r.len)
+        .map(|r| {
+            writeln!(Writer, "start: {:#x}, len: {:#x}", r.start_addr, r.len).unwrap();
+            r.start_addr + r.len
+        })
         .max()
         .expect("no physical memory regions found");
 
@@ -57,21 +59,24 @@ pub extern "C" fn _start(info: &BiosInfo) -> ! {
     let mut frame_allocator = {
         let kernel_end = PhysFrame::containing_address(kernel_start + kernel_size - 1u64);
         let next_free = kernel_end + 1;
-        LegacyFrameAllocator::new_starting_at(next_free, e820_memory_map.iter().copied())
+        LegacyFrameAllocator::new_starting_at(
+            next_free,
+            memory_map.iter().copied().map(MemoryRegion),
+        )
     };
 
-    // We identity-map all memory, so the offset between physical and virtual addresses is 0
+    // We identity-mapped all memory, so the offset between physical and virtual addresses is 0
     let phys_offset = VirtAddr::new(0);
 
     let mut bootloader_page_table = {
         let frame = x86_64::registers::control::Cr3::read().0;
         let table: *mut PageTable = (phys_offset + frame.start_address().as_u64()).as_mut_ptr();
         unsafe { OffsetPageTable::new(&mut *table, phys_offset) }
     };
-    // identity-map remaining physical memory (first gigabyte is already identity-mapped)
+    // identity-map remaining physical memory (first 10 gigabytes are already identity-mapped)
     {
         let start_frame: PhysFrame<Size2MiB> =
-            PhysFrame::containing_address(PhysAddr::new(4096 * 512 * 512));
+            PhysFrame::containing_address(PhysAddr::new(4096 * 512 * 512 * 10));
         let end_frame = PhysFrame::containing_address(PhysAddr::new(max_phys_addr - 1));
         for frame in PhysFrame::range_inclusive(start_frame, end_frame) {
             unsafe {

bios/stage-4/src/memory_descriptor.rs

@@ -1,18 +1,19 @@
 use bootloader_api::info::MemoryRegionKind;
+use bootloader_x86_64_bios_common::E820MemoryRegion;
 use bootloader_x86_64_common::legacy_memory_region::LegacyMemoryRegion;
 use x86_64::PhysAddr;
 
-impl LegacyMemoryRegion for E820MemoryRegion {
+impl LegacyMemoryRegion for MemoryRegion {
     fn start(&self) -> PhysAddr {
-        PhysAddr::new(self.start_addr)
+        PhysAddr::new(self.0.start_addr)
     }
 
     fn len(&self) -> u64 {
-        self.len
+        self.0.len
     }
 
     fn kind(&self) -> MemoryRegionKind {
-        match self.region_type {
+        match self.0.region_type {
             1 => MemoryRegionKind::Usable,
             other => MemoryRegionKind::UnknownBios(other),
         }
@@ -29,9 +30,4 @@ impl LegacyMemoryRegion for E820MemoryRegion {
 #[doc(hidden)]
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 #[repr(C)]
-pub struct E820MemoryRegion {
-    pub start_addr: u64,
-    pub len: u64,
-    pub region_type: u32,
-    pub acpi_extended_attributes: u32,
-}
+pub struct MemoryRegion(pub E820MemoryRegion);

tests/runner/src/lib.rs

@@ -5,13 +5,9 @@ const QEMU_ARGS: &[&str] = &[
     "isa-debug-exit,iobase=0xf4,iosize=0x04",
     "-serial",
     "stdio",
-    // "-display",
-    // "none",
+    "-display",
+    "none",
     "--no-reboot",
-    // "-d",
-    // "int",
-    "-s",
-    // "-S",
 ];
 
 pub fn run_test_kernel(kernel_binary_path: &str) {