Get memory areas as argument instead of from hardcoded pointer

src/arch/x86_64/rmm.rs

@@ -1,4 +1,8 @@
-use core::cmp;
+use core::{
+    cmp,
+    mem,
+    slice,
+};
 use rmm::{
     KILOBYTE,
     MEGABYTE,
@@ -29,6 +33,25 @@ extern "C" {
     static mut __rodata_end: u8;
 }
 
+// Keep synced with OsMemoryKind in bootloader
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(u64)]
+pub enum BootloaderMemoryKind {
+    Null = 0,
+    Free = 1,
+    Reclaim = 2,
+    Reserved = 3,
+}
+
+// Keep synced with OsMemoryEntry in bootloader
+#[derive(Clone, Copy, Debug)]
+#[repr(packed)]
+pub struct BootloaderMemoryEntry {
+    pub base: u64,
+    pub size: u64,
+    pub kind: BootloaderMemoryKind,
+}
+
 unsafe fn page_flags<A: Arch>(virt: VirtualAddress) -> PageFlags<A> {
     let virt_addr = virt.data();
 
@@ -220,7 +243,8 @@ pub unsafe fn init(
     kernel_base: usize, kernel_size: usize,
     stack_base: usize, stack_size: usize,
     env_base: usize, env_size: usize,
-    acpi_base: usize, acpi_size: usize
+    acpi_base: usize, acpi_size: usize,
+    areas_base: usize, areas_size: usize,
 ) {
     type A = RmmA;
 
@@ -240,17 +264,21 @@ pub unsafe fn init(
     let acpi_size_aligned = ((acpi_size + (A::PAGE_SIZE - 1))/A::PAGE_SIZE) * A::PAGE_SIZE;
     let acpi_end = acpi_base + acpi_size_aligned;
 
+    let bootloader_areas = slice::from_raw_parts(
+        areas_base as *const BootloaderMemoryEntry,
+        areas_size / mem::size_of::<BootloaderMemoryEntry>()
+    );
+
     // Copy memory map from bootloader location, and page align it
     let mut area_i = 0;
-    for i in 0..512 {
-        let old = *(0x500 as *const crate::memory::MemoryArea).add(i);
-        if old._type != 1 {
+    for bootloader_area in bootloader_areas.iter() {
+        if bootloader_area.kind != BootloaderMemoryKind::Free {
             // Not a free area
             continue;
         }
 
-        let mut base = old.base_addr as usize;
-        let mut size = old.length as usize;
+        let mut base = bootloader_area.base as usize;
+        let mut size = bootloader_area.size as usize;
 
         print!("{:X}:{:X}", base, size);
 

src/arch/x86_64/start.rs

@@ -56,6 +56,9 @@ pub struct KernelArgs {
     acpi_rsdps_base: u64,
     /// The size of the RSDPs region.
     acpi_rsdps_size: u64,
+
+    areas_base: u64,
+    areas_size: u64,
 }
 
 /// The entry to Rust, all things must be initialized
@@ -72,6 +75,8 @@ pub unsafe extern fn kstart(args_ptr: *const KernelArgs) -> ! {
         let env_size = args.env_size as usize;
         let acpi_rsdps_base = args.acpi_rsdps_base;
         let acpi_rsdps_size = args.acpi_rsdps_size;
+        let areas_base = args.areas_base as usize;
+        let areas_size = args.areas_size as usize;
 
         // BSS should already be zero
         {
@@ -99,6 +104,7 @@ pub unsafe extern fn kstart(args_ptr: *const KernelArgs) -> ! {
         info!("Stack: {:X}:{:X}", stack_base, stack_base + stack_size);
         info!("Env: {:X}:{:X}", env_base, env_base + env_size);
         info!("RSDPs: {:X}:{:X}", acpi_rsdps_base, acpi_rsdps_base + acpi_rsdps_size);
+        info!("Areas: {:X}:{:X}", areas_base, areas_base + areas_size);
 
         // Set up GDT before paging
         gdt::init();
@@ -111,7 +117,8 @@ pub unsafe extern fn kstart(args_ptr: *const KernelArgs) -> ! {
             kernel_base, kernel_size,
             stack_base, stack_size,
             env_base, env_size,
-            acpi_rsdps_base as usize, acpi_rsdps_size as usize
+            acpi_rsdps_base as usize, acpi_rsdps_size as usize,
+            areas_base, areas_size,
         );
 
         // Initialize paging