Add rust allocation with staticalloc mod

Author: Filip Chovanec

config/profiles/default/rkernel.rs

@@ -6,3 +6,6 @@ pub const MESSAGE_FIRST: &str = "Hello World!\n";
 /// If it overflows , a kernel panic is triggered
 pub const LOG_STATIC_CAPACITY: usize = 204_800;
 
+/// The static allocator allocator is used by rust prior to any other being setup. It takes space in the kernel binary itself. Using this we can size its size.
+///
+pub const STATIC_ALLOCATOR_SIZE_BYTES: usize = 100_000;

kernel/.cargo/config.toml

@@ -1,2 +1,2 @@
 [unstable]
-build-std = ["core", "compiler_builtins"]
+build-std = ["core", "compiler_builtins", "alloc"]

kernel/limine.conf

@@ -2,5 +2,4 @@ timeout = 0
 
 / REZ_OS
     protocol: limine
-    textmode: yes
     path: boot():/kernel.x86_64.bin

kernel/src/driver/lfb.rs

@@ -5,28 +5,8 @@ use tinybmp::Bmp;
 
 pub fn init() {
     let fb = crate::limine::framebuffer0();
-    let circle = Circle::new(Point::new(22, 22), 140).into_styled(PrimitiveStyle::with_stroke(
-        crate::limine::LColor {
-            r: 250,
-            g: 250,
-            b: 250,
-        },
-        1,
-    ));
-    circle.draw(fb).unwrap();
 
     let bmp_data = include_bytes!("../../../cat.bmp");
     let bmp = Bmp::from_slice(bmp_data).unwrap();
     Image::new(&bmp, Point::new(200, 200)).draw(fb).unwrap();
-
-    /*
-    //draw_pixel(fb, 600, 600, (250, 250, 250)).unwrap();
-    let mut a = 0;
-    loop {
-        for x in 1..1200 {
-            for y in 1..800 {
-                draw_pixel(fb, x, y, (a, 250 - a, a)).unwrap();
-            }
-        }
-    }*/
 }

kernel/src/main.rs

@@ -24,7 +24,8 @@
 */
 
 use core::panic::{self, PanicInfo};
-// Do not remove these imports, they may useless but they prevent link errors
+extern crate alloc;
+// Do not remove these imports, they may look useless but they prevent link errors
 #[allow(unused_imports)]
 use rlibc;
 use rlibcex;
@@ -144,6 +145,7 @@ pub extern "C" fn kmain() {
     log!("HHDM: 0x{:016X}\n", hhdm);
 
     log!("Framebuffer 0: {:?}\n", limine::framebuffer0());
+    alloc::boxed::Box::new(4);
     driver::lfb::init();
 
     log!("Nothing to do!\n");

kernel/src/memman/mod.rs

@@ -5,3 +5,4 @@
  */
 
 pub mod map;
+pub mod staticalloc;

kernel/src/memman/staticalloc.rs

@@ -0,0 +1,60 @@
+use crate::log;
+use core::alloc::GlobalAlloc;
+extern crate alloc;
+
+const MAX: usize = crate::config::STATIC_ALLOCATOR_SIZE_BYTES;
+
+#[global_allocator]
+static GLOBAL_STATIC_ALLOCATOR: StaticAllocator<MAX> = StaticAllocator::new();
+
+struct StaticAllocator<const SIZE: usize> {
+    buffer: [u8; SIZE],
+    bump_addr: spin::Mutex<usize>,
+}
+
+impl<const SIZE: usize> StaticAllocator<SIZE> {
+    const fn new() -> Self {
+        Self {
+            // just a data holder, not actually referenced but still needed
+            buffer: [0; SIZE],
+            // get properly inited in its `alloc` definition
+            bump_addr: spin::Mutex::new(0),
+        }
+    }
+}
+
+unsafe impl<const SIZE: usize> GlobalAlloc for StaticAllocator<SIZE> {
+    unsafe fn alloc(&self, layout: core::alloc::Layout) -> *mut u8 {
+        // expect by rust docs
+        if layout.size() == 0 {
+            log!("ZERO!");
+            return core::ptr::null_mut();
+        }
+
+        let mut bumplock = self.bump_addr.lock();
+
+        // kinda bad design, but its late and works so idc
+        if *bumplock == 0 {
+            *bumplock = self.buffer.as_ptr() as usize;
+        }
+
+        // we take the first free chunk, or a bit more for it to be aligned
+        let first_start = *bumplock;
+        let aligned_start = if first_start % layout.align() > 0 {
+            first_start + layout.align() - (first_start % layout.align())
+        } else {
+            first_start
+        };
+        // if the returned chunk is greater than last address of buffer, we ran out of memory :(
+        if aligned_start + layout.size() >= self.buffer.as_ptr() as usize + self.buffer.len() {
+            log!("NO SPACE :(!");
+            return core::ptr::null_mut();
+        }
+        // upadte that ting
+        *bumplock = aligned_start + layout.size();
+
+        aligned_start as *mut u8
+    }
+    // we dont free this lmao
+    unsafe fn dealloc(&self, ptr: *mut u8, layout: core::alloc::Layout) {}
+}

smeltfile.py

@@ -89,4 +89,10 @@ def isoroot():
 
     return File(output)
 
+@task("docs")
+def doc_kernel():
+    use(file_tree("kernel/src/"))
+    shell("cd kernel && cargo doc --document-private-items")
+    return File("kernel/target/doc/kernel/index.html")
+
 smelt3.cli()