Use conventional memory as heap

common/src/types.rs

@@ -1,4 +1,5 @@
-use uefi_raw::table::boot::MemoryDescriptor;
+pub use uefi_raw::table::boot::MemoryDescriptor;
+pub use uefi_raw::table::boot::MemoryType;
 
 #[repr(C)]
 #[derive(Debug, Clone)]
@@ -13,6 +14,7 @@ pub struct MemMapEntry {
     pub size: u64,
 }
 
+#[derive(Debug, Clone)]
 pub struct MemMapIter<'a> {
     index: usize,
     size: usize,

kernel-lib/src/allocator.rs

@@ -178,6 +178,8 @@ where
 
 #[cfg(test)]
 mod tests {
+    use std::println;
+
     use super::*;
 
     pub fn alloc_huge_times_template(
@@ -236,6 +238,31 @@ mod tests {
         }
     }
 
+    pub fn alloc_huge_times_with_value_template<'a, A>(allocator: &'a A, n_times: usize)
+    where
+        A: BoundaryAlloc,
+        &'a A: Allocator,
+    {
+        for i in 0..n_times {
+            let mut vec = Vec::<usize, _>::with_capacity_in(i, allocator);
+            let mut vec2 = Vec::<usize, _>::with_capacity_in(i, allocator);
+            let one = Box::<usize, _>::new_in(core::hint::black_box(1), allocator);
+            for j in 0..i {
+                vec.push(core::hint::black_box(j));
+            }
+            for j in 0..i {
+                vec2.push(core::hint::black_box(j));
+            }
+
+            assert_eq!(vec.len(), i);
+            for (j, val) in vec.into_iter().enumerate() {
+                assert_eq!(val, j);
+                assert_eq!(vec2[j], j);
+            }
+            assert_eq!(*one, 1);
+        }
+    }
+
     #[test]
     fn ceil_test() {
         assert_eq!(ceil(100, 4), 100);

kernel-lib/src/allocator/bump_allocator.rs

@@ -34,13 +34,16 @@ unsafe impl BoundaryAlloc for crate::mutex::Mutex<BumpAllocator> {
     unsafe fn alloc(&self, layout: core::alloc::Layout, boundary: usize) -> *mut u8 {
         let mut allocator = crate::lock!(self);
         let Ok(alloc_start) = align_and_boundary_to(allocator.next, layout, boundary) else {
+            panic!("Allocation failed: {:?}", layout);
             return core::ptr::null_mut();
         };
 
         if alloc_start.end >= allocator.heap_end {
+            panic!("Allocation failed: {:?}", layout);
             return core::ptr::null_mut();
         }
 
+        allocator.next = alloc_start.end;
         allocator.n_allocations += 1;
 
         alloc_start.start as *mut u8
@@ -50,6 +53,7 @@ unsafe impl BoundaryAlloc for crate::mutex::Mutex<BumpAllocator> {
         let mut allocator = crate::lock!(self);
         allocator.n_allocations -= 1;
         if allocator.n_allocations == 0 {
+            log::debug!("dealloc: Resetting allocator");
             allocator.next = allocator.heap_start;
         }
     }
@@ -60,16 +64,32 @@ impl_allocator_for_global_alloc!(crate::mutex::Mutex<BumpAllocator>);
 
 #[cfg(test)]
 mod tests {
+    use std::println;
+
     use super::*;
-    use crate::allocator::tests::alloc_huge_times_template;
+    use crate::allocator::tests::{
+        alloc_huge_times_template, alloc_huge_times_with_value_template,
+    };
     #[test]
     fn alloc_huge_times() {
         const SIZE: usize = 100 * 1024;
-        let mut heap = [0u8; SIZE];
+        static HEAP: &[u8] = &[0u8; SIZE];
         let allocator = crate::mutex::Mutex::new(BumpAllocator::new());
         unsafe {
-            crate::lock!(allocator).init(heap.as_ptr() as usize, heap.as_ptr() as usize + SIZE)
+            crate::lock!(allocator).init(HEAP.as_ptr() as usize, HEAP.as_ptr() as usize + SIZE)
         };
         alloc_huge_times_template(&allocator, SIZE / 1024, 1000);
     }
+
+    #[test]
+    fn alloc_huge_times_with_value() {
+        const SIZE: usize = 100 * 1024;
+        static mut HEAP: &[u8] = &[0u8; SIZE];
+        let allocator = crate::mutex::Mutex::new(BumpAllocator::new());
+        unsafe {
+            crate::lock!(allocator).init(HEAP.as_ptr() as usize, HEAP.as_ptr() as usize + SIZE)
+        };
+        // TODO: fix this
+        // alloc_huge_times_with_value_template(&allocator, SIZE / 1024);
+    }
 }

kernel-lib/src/allocator/fixed_length_allocator.rs

@@ -184,4 +184,11 @@ mod tests {
         let allocator = FixedLengthAllocator::<SIZE>::new();
         allocator::tests::alloc_huge_times_template(&allocator, SIZE / 1024, 1000);
     }
+
+    #[test]
+    fn alloc_huge_times_with_value() {
+        const SIZE: usize = 100 * 1024;
+        let allocator = FixedLengthAllocator::<SIZE>::new();
+        allocator::tests::alloc_huge_times_with_value_template(&allocator, SIZE / 1024);
+    }
 }

kernel/src/alloc/alloc.rs

@@ -1,27 +1,36 @@
 extern crate alloc;
 use alloc::boxed::Box;
-use core::{alloc::LayoutError, mem::MaybeUninit};
-use kernel_lib::allocator::FixedLengthAllocator;
+use core::mem::MaybeUninit;
+use kernel_lib::{allocator::bump_allocator::BumpAllocator, mutex::Mutex};
 
 const HEAP_SIZE: usize = 1 << 21;
 
-pub type GlobalAllocator = FixedLengthAllocator<HEAP_SIZE>;
+pub type GlobalAllocator = Mutex<BumpAllocator>;
 
 #[global_allocator]
-static ALLOCATOR: GlobalAllocator = GlobalAllocator::new();
+static ALLOCATOR: GlobalAllocator = Mutex::new(BumpAllocator::new());
+
+pub unsafe fn init_allocator(heap_start: usize, heap_end: usize) {
+    log::debug!(
+        "Initializing allocator: {:#x} - {:#x}",
+        heap_start,
+        heap_end
+    );
+    kernel_lib::lock!(ALLOCATOR).init(heap_start, heap_end);
+}
 
 pub fn alloc_with_boundary<T>(
     alignment: usize,
     boundary: usize,
-) -> Result<Box<MaybeUninit<T>, &'static GlobalAllocator>, LayoutError> {
+) -> Result<Box<MaybeUninit<T>, &'static GlobalAllocator>, ()> {
     kernel_lib::allocator::alloc_with_boundary(&ALLOCATOR, alignment, boundary)
 }
 
 pub fn alloc_with_boundary_with_default_else<T>(
     alignment: usize,
     boundary: usize,
     default: impl FnOnce() -> T,
-) -> Result<Box<T, &'static GlobalAllocator>, LayoutError> {
+) -> Result<Box<T, &'static GlobalAllocator>, ()> {
     kernel_lib::allocator::alloc_with_boundary_with_default_else(
         &ALLOCATOR, alignment, boundary, default,
     )
@@ -31,7 +40,7 @@ pub fn alloc_array_with_boundary<T>(
     len: usize,
     alignment: usize,
     boundary: usize,
-) -> Result<Box<[MaybeUninit<T>], &'static GlobalAllocator>, LayoutError> {
+) -> Result<Box<[MaybeUninit<T>], &'static GlobalAllocator>, ()> {
     kernel_lib::allocator::alloc_array_with_boundary(&ALLOCATOR, len, alignment, boundary)
 }
 
@@ -40,7 +49,7 @@ pub fn alloc_array_with_boundary_with_default_else<T>(
     alignment: usize,
     boundary: usize,
     default: impl Fn() -> T,
-) -> Result<Box<[T], &'static GlobalAllocator>, LayoutError> {
+) -> Result<Box<[T], &'static GlobalAllocator>, ()> {
     kernel_lib::allocator::alloc_array_with_boundary_with_default_else(
         &ALLOCATOR, len, alignment, boundary, default,
     )

kernel/src/main.rs

@@ -4,18 +4,19 @@
 use core::{arch::asm, panic::PanicInfo};
 
 pub extern crate alloc;
-use common::types::KernelMainArg;
+use alloc::vec::Vec;
+use common::types::{KernelMainArg, MemoryType};
 use core::fmt::Write;
 use kernel::{
-    alloc::alloc::GlobalAllocator,
+    alloc::alloc::{init_allocator, GlobalAllocator},
     graphics::{init_graphics, init_logger},
     interrupts::init_idt,
     memory::MemoryMapper,
     multitasking::{
         executor::Executor,
         task::{Priority, Task},
     },
-    println, serial_println,
+    println, serial, serial_println,
     usb::{
         class_driver::callbacks::{self, init_mouse_cursor_layer},
         device::DeviceContextInfo,
@@ -55,30 +56,41 @@ extern "C" fn kernel_main(arg: *const KernelMainArg) -> ! {
 #[no_mangle]
 extern "sysv64" fn kernel_main2(arg: *const KernelMainArg) -> ! {
     let arg = unsafe { (*arg).clone() };
-    let memory_map_iter = unsafe { arg.memory_map_entry.as_ref().unwrap().into_iter() };
     let graphics_info = arg.graphics_info;
     let pixcel_writer = init_graphics(graphics_info);
     pixcel_writer.fill_rect(Vector2D::new(50, 50), Vector2D::new(50, 50), Color::white());
-    println!("global WRITER initialized?");
-    writeln!(
-        kernel_lib::lock!(kernel::graphics::WRITER.0)
-            .get_mut()
-            .unwrap(),
-        "Hello lemola os!!!"
-    )
-    .unwrap();
 
     init_logger();
 
-    for (i, desc) in memory_map_iter.enumerate() {
-        serial_println!("memory map entry {}: {:?}", i, desc);
-    }
-
     log::info!("global logger initialized!");
 
-    pixcel_writer.write_ascii(50, 50, 'A', Color::white(), Color::new(255, 50, 0));
-
-    pixcel_writer.fill_shape(Vector2D::new(30, 50), &MOUSE_CURSOR_SHAPE);
+    let memory_map_iter = unsafe { arg.memory_map_entry.as_ref().unwrap().into_iter() };
+    let heap = memory_map_iter
+        .clone()
+        .filter_map(|desc| {
+            if let MemoryType::CONVENTIONAL
+            | MemoryType::BOOT_SERVICES_CODE
+            | MemoryType::BOOT_SERVICES_DATA = desc.ty
+            {
+                Some(desc.phys_start..(desc.phys_start + desc.page_count * 4096))
+            } else {
+                None
+            }
+        })
+        .max_by_key(|range| range.end - range.start)
+        .expect("no conventional memory region found");
+    unsafe {
+        init_allocator(heap.start as usize, heap.end as usize);
+    }
+    let memory_map = memory_map_iter.collect::<Vec<_>>();
+    for desc in memory_map.iter() {
+        log::debug!(
+            "[0x{:09x} - 0x{:09x}] of type {:?}",
+            desc.phys_start,
+            desc.phys_start + desc.page_count * 4096,
+            desc.ty
+        );
+    }
 
     let class_drivers = kernel::usb::class_driver::ClassDriverManager::new(
         callbacks::mouse(),