Add a heap_allocator module with a basic bump allocator

src/lib.rs

@@ -3,6 +3,7 @@
 #![feature(alloc)]
 #![feature(const_unique_new)]
 #![feature(unique)]
+#![feature(allocator_api)]
 #![no_std]
 
 

src/memory/heap_allocator.rs

@@ -0,0 +1,51 @@
+use alloc::heap::{Alloc, AllocErr, Layout};
+
+/// A simple allocator that allocates memory linearly and ignores freed memory.
+#[derive(Debug)]
+pub struct BumpAllocator {
+    heap_start: usize,
+    heap_end: usize,
+    next: usize,
+}
+
+impl BumpAllocator {
+    pub const fn new(heap_start: usize, heap_end: usize) -> Self {
+        Self { heap_start, heap_end, next: heap_start }
+    }
+}
+
+unsafe impl Alloc for BumpAllocator {
+    unsafe fn alloc(&mut self, layout: Layout) -> Result<*mut u8, AllocErr> {
+        let alloc_start = align_up(self.next, layout.align());
+        let alloc_end = alloc_start.saturating_add(layout.size());
+
+        if alloc_end <= self.heap_end {
+            self.next = alloc_end;
+            Ok(alloc_start as *mut u8)
+        } else {
+            Err(AllocErr::Exhausted{ request: layout })
+        }
+    }
+
+    unsafe fn dealloc(&mut self, ptr: *mut u8, layout: Layout) {
+        // do nothing, leak memory
+    }
+}
+
+/// Align downwards. Returns the greatest x with alignment `align`
+/// so that x <= addr. The alignment must be a power of 2.
+pub fn align_down(addr: usize, align: usize) -> usize {
+    if align.is_power_of_two() {
+        addr & !(align - 1)
+    } else if align == 0 {
+        addr
+    } else {
+        panic!("`align` must be a power of 2");
+    }
+}
+
+/// Align upwards. Returns the smallest x with alignment `align`
+/// so that x >= addr. The alignment must be a power of 2.
+pub fn align_up(addr: usize, align: usize) -> usize {
+    align_down(addr + align - 1, align)
+}

src/memory/mod.rs

@@ -3,6 +3,7 @@ pub use self::paging::remap_the_kernel;
 use self::paging::PhysicalAddress;
 
 mod area_frame_allocator;
+mod heap_allocator;
 mod paging;
 
 pub const PAGE_SIZE: usize = 4096;