Set up the physical memory allocators.

1 files changed, 27 insertions, 24 deletions

diff --git a/crates/kernel/src/lib.rs b/crates/kernel/src/lib.rs
index 8e418e7..6e09d2b 100644
--- a/crates/kernel/src/lib.rs
+++ b/crates/kernel/src/lib.rs
@@ -1,8 +1,10 @@
 //! The static library that forms the core of the kernel.
 #![no_std]
 
-use crate::arch::{sleep_forever, PAGE_SIZE};
+use crate::arch::{sleep_forever, PAGE_SIZE, PAGE_SIZE_BITS};
+use core::ptr::NonNull;
 use log::{debug, info, warn};
+use vernos_alloc_buddy::BuddyAllocator;
 use vernos_alloc_physmem_free_list::FreeListAllocator;
 use vernos_device_tree::FlattenedDeviceTree;
 use vernos_utils::dbg;
@@ -35,22 +37,19 @@ pub unsafe extern "C" fn hart0_boot(device_tree: *const u8) -> ! {
     // Find the available physical memory areas and initialize the physical memory
     // free-list.
     let mut physical_memory_free_list = FreeListAllocator::<PAGE_SIZE>::new();
-    dbg!(physical_memory_free_list);
-
-    /*
+    let mut physical_memory_region_count = 0;
     flattened_device_tree
-        .for_each_node(|node| {
-            if node.is_unit(&["", "memory"]) {
-                // Get the memory ranges.
-                let Some(reg) = node.get_reg_usize() else {
-                    warn!("{}reg was not valid", node.name());
-                    return Ok(());
-                };
+        .for_each_memory_range::<_, PAGE_SIZE>(|addrs| {
+            dbg!(&addrs);
+            let len_bytes = addrs.end - addrs.start;
+            assert!(addrs.start.trailing_zeros() as usize >= PAGE_SIZE_BITS);
+            assert!(len_bytes.trailing_zeros() as usize >= PAGE_SIZE_BITS);
+            // UNWRAP: for_each_memory_range avoids returning the zero address.
+            let addr = NonNull::new(addrs.start as *mut [u8; PAGE_SIZE]).unwrap();
+            let len_pages = len_bytes >> PAGE_SIZE_BITS;
 
-                for (addr, size) in reg {
-                    physical_memory_free_list.add_range(addr..addr + size);
-                }
-            }
+            physical_memory_free_list.add(addr, len_pages);
+            physical_memory_region_count += 1;
             Ok(())
         })
         .unwrap_or_else(|err| void::unreachable(err));
@@ -58,23 +57,27 @@ pub unsafe extern "C" fn hart0_boot(device_tree: *const u8) -> ! {
     // Log the physical memory we found.
     debug!(
         "found {} usable regions of physical memory{}",
-        physical_memory_free_list.len(),
-        if physical_memory_free_list.is_empty() {
+        physical_memory_region_count,
+        if physical_memory_region_count == 0 {
             ""
         } else {
             ":"
         }
     );
-    for region in physical_memory_free_list.drain() {
+    for (addr, len_pages) in physical_memory_free_list.iter() {
         debug!(
-            "{:p}..{:p} ({} byte{})",
-            region.start as *const u8,
-            region.end as *const u8,
-            region.len(),
-            if region.len() == 1 { "" } else { "s" }
+            "{:p}..{:p} ({} bytes)",
+            addr.as_ptr(),
+            addr.as_ptr().wrapping_add(len_pages),
+            len_pages << PAGE_SIZE_BITS,
         )
     }
-    */
+
+    // Initialize the buddy allocator.
+    let alloc_buddy =
+        BuddyAllocator::<PAGE_SIZE, PAGE_SIZE_BITS, 19>::new(physical_memory_free_list)
+            .expect("failed to configure the buddy allocator");
+    dbg!(alloc_buddy.debug_free_lists());
 
     // After this point, everything else is for debugging.
     #[cfg(target_arch = "riscv64")]