pass usable memory to kernel

nel_os_bootloader/src/main.rs

@@ -1,15 +1,17 @@
+#![feature(vec_into_raw_parts)]
 #![no_main]
 #![no_std]
 
 extern crate alloc;
 
-use alloc::{boxed::Box, vec};
+use alloc::{boxed::Box, vec, vec::Vec};
 use core::{arch::asm, slice};
 use goblin::elf;
+use nel_os_common::memory;
 use uefi::{
     allocator::Allocator,
     boot::{AllocateType, MemoryType, ScopedProtocol},
-    mem::memory_map::MemoryMap,
+    mem::memory_map::{MemoryMap, MemoryMapOwned},
     prelude::*,
     println,
     proto::media::{
@@ -106,31 +108,51 @@ fn main() -> Status {
 
     println!("nel_os bootloader");
 
-    let memory_map = uefi::boot::memory_map(MemoryType::LOADER_DATA).unwrap();
-    println!("memory_map len: {}", memory_map.len());
-
-    println!("Conventional memory:");
-    for entry in memory_map.entries() {
-        if entry.ty != MemoryType::CONVENTIONAL {
-            continue;
-        }
-        println!("    Size: {:?}MiB", entry.page_count * 4 / 1024);
-        println!("    PhysStart: {:?}", entry.phys_start);
-    }
-
     let kernel = read_kernel(cstr16!("nel_os_kernel.elf"));
 
     let entry_point = load_elf(kernel);
 
     println!("Entry point: {:#x}", entry_point);
 
-    let entry: extern "sysv64" fn() = unsafe { core::mem::transmute(entry_point) };
+    let entry: extern "sysv64" fn(&memory::UsableMemory) =
+        unsafe { core::mem::transmute(entry_point) };
 
-    unsafe {
-        let _ = uefi::boot::exit_boot_services(Some(MemoryType::LOADER_DATA));
-    }
+    let size = uefi::boot::memory_map(MemoryType::LOADER_DATA)
+        .unwrap()
+        .len()
+        + 8 * core::mem::size_of::<memory::Range>();
+    let mut ranges: Vec<memory::Range> = Vec::with_capacity(size);
 
-    entry();
+    println!("Usable memory size: {}", size);
+
+    let memory_map = unsafe { uefi::boot::exit_boot_services(Some(MemoryType::LOADER_DATA)) };
+
+    memory_map
+        .entries()
+        .filter(|entry| {
+            matches!(
+                entry.ty,
+                MemoryType::CONVENTIONAL
+                    | MemoryType::BOOT_SERVICES_CODE
+                    | MemoryType::BOOT_SERVICES_DATA
+            )
+        })
+        .for_each(|entry| {
+            ranges.push(memory::Range {
+                start: entry.phys_start,
+                end: entry.phys_start + entry.page_count * 4096,
+            })
+        });
+
+    let usable_memory = {
+        let (ptr, len, _) = ranges.into_raw_parts();
+        memory::UsableMemory {
+            ranges: ptr as *const memory::Range,
+            len: len as u64,
+        }
+    };
+
+    entry(&usable_memory);
 
     hlt_loop();
 }

nel_os_kernel/Cargo.lock

@@ -45,11 +45,16 @@ dependencies = [
  "scopeguard",
 ]
 
+[[package]]
+name = "nel_os_common"
+version = "0.1.0"
+
 [[package]]
 name = "nel_os_kernel"
 version = "0.1.0"
 dependencies = [
  "lazy_static",
+ "nel_os_common",
  "spin 0.10.0",
  "uart_16550",
  "x86_64",

nel_os_kernel/Cargo.toml

@@ -8,3 +8,4 @@ lazy_static = { version = "1.5.0", features = ["spin_no_std"] }
 spin = "0.10.0"
 uart_16550 = "0.3.2"
 x86_64 = "0.15.2"
+nel_os_common = { path = "../nel_os_common" }

nel_os_kernel/src/main.rs

@@ -58,7 +58,7 @@ fn hlt_loop() -> ! {
 }
 
 #[unsafe(no_mangle)]
-pub extern "sysv64" fn main() {
+pub extern "sysv64" fn main(usable_memory: &nel_os_common::memory::UsableMemory) {
     println!("{} v{}", BANNER, PKG_VERSION);
 
     let virt = VirtAddr::new(
@@ -70,5 +70,7 @@ pub extern "sysv64" fn main() {
     let phys = paging::translate_addr(virt);
     info!("Level 4 page table: {:?} -> {:?}", virt, phys);
 
+    info!("Usable memory len: {}", usable_memory.len);
+
     hlt_loop();
 }