fixed interrupts (temporary, we need to do a real fix for this)

TODO:

* Debugging, tracing support.
* Logging infra so we can may pass a loglevel like on Linux.

.cargo/config.toml

@@ -17,8 +17,5 @@ runner = "scripts/run_debug.sh"
 [target.'cfg(all(target_arch = "x86_64", target_os = "none", not(debug_assertions)))']
 runner = "scripts/run_release.sh"
 
-# [registry]
-# default = "gitea"
-
 [registries.gitea]
 index = "sparse+https://git.zxq5.dev/api/packages/OsDev/cargo/" # Sparse index

.idea/FoundryOS.iml

@@ -6,6 +6,7 @@
       <sourceFolder url="file://$MODULE_DIR$/lib_example/src" isTestSource="false" />
       <sourceFolder url="file://$MODULE_DIR$/libk/src" isTestSource="false" />
       <sourceFolder url="file://$MODULE_DIR$/libm/src" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/kernel_fonts/src" isTestSource="false" />
       <excludeFolder url="file://$MODULE_DIR$/target" />
     </content>
     <orderEntry type="inheritedJdk" />

.idea/codeStyles/codeStyleConfig.xml

@@ -0,0 +1,5 @@
+<component name="ProjectCodeStyleConfiguration">
+  <state>
+    <option name="PREFERRED_PROJECT_CODE_STYLE" value="Default" />
+  </state>
+</component>

.vscode/settings.json

@@ -5,5 +5,6 @@
         "editor.defaultFormatter": "rust-lang.rust-analyzer",
         "editor.formatOnSave": true
     },
-    "rust-analyzer.check.command": "clippy"
+    "rust-analyzer.check.command": "clippy",
+    "rust-analyzer.cargo.buildScripts.enable": true
 }

docs/Planning & To-Dos.md

@@ -7,12 +7,17 @@
 > 	- [ ] write a script to run tests
 > 	- [ ] a release should only be published if all tests pass
 
+> [!todo] Memory
+> - [ ] make sure page tables are correct. we're still getting the annoying page fault errors for the APIC
+> - [ ] page allocator
+>   - [ ] e
+
 > [!todo] Allocator
-> - [ ] learn about several allocator designs and decide on the optimal one
-> - [ ] implementation
-> 	- [ ] implement an allocate method
-> 	- [ ] implement a deallocate method
-> 	- [ ] set the global allocator
+> - [x] learn about several allocator designs and decide on the optimal one
+> - [x] implementation
+> 	- [x] implement an allocate method
+> 	- [x] implement a deallocate method
+> 	- [x] set the global allocator
 > - [ ] testing
 > 	- [ ] write unit tests
 > 		- [ ] many allocations

kernel/Cargo.toml

@@ -19,6 +19,11 @@ futures-util = { version = "0.3.31", default-features = false, features = [
     "alloc",
 ] }
 linked_list_allocator = { version = "0.10.5", features = ["use_spin"] }
+# gimli = { version = "0.31.1", default-features = false, features = ["read"] }
+# elf = { version = "0.7.4", default-features = false, features = ["nightly"] }
+# fallible-iterator = "0.3.0"
+# framehop = { version = "0.13.2", default-features = false }
+# object = { version = "0.36.7", default-features = false, features = ["read"] }
 
 [build-dependencies]
 cc = "1.2.14"

kernel/linker.ld

@@ -62,9 +62,8 @@ SECTIONS
         *(COMMON)
     } :data
 
-    /* Discard .note.* and .eh_frame* since they may cause issues on some hosts. */
+    /* Discard .note.* and ~~.eh_frame*~~ since they may cause issues on some hosts. */
     /DISCARD/ : {
-        *(.eh_frame*)
         *(.note .note.*)
     }
 }

kernel/src/arch/x86_64/cpu/apic.rs

@@ -1,15 +1,20 @@
+#![expect(unused)]
+
 use core::arch::x86_64::__cpuid;
 
-use crate::arch::x86_64::memory::memory_map::PHYSICAL_MEMORY_OFFSET;
-use crate::serial_print;
+use crate::arch::x86_64::{
+    cpu::msr::*,
+    memory::{
+        FRAME_ALLOCATOR, OFFSET_PAGE_TABLE, mapping::PHYSICAL_MEMORY_OFFSET,
+    },
+};
+
+use x86_64::structures::paging::Translate;
 use x86_64::{
     PhysAddr, VirtAddr,
     structures::paging::{Mapper, Page, PageTableFlags, PhysFrame, Size4KiB},
 };
 
-use crate::arch::x86_64::cpu::msr::*;
-use crate::arch::x86_64::memory::{FRAME_ALLOCATOR, OFFSET_PAGE_TABLE};
-
 const IA32_APIC_BASE_MSR: u32 = 0x1b;
 const IA32_APIC_BASE_MSR_BSP: u64 = 0x100;
 const IA32_APIC_BASE_MSR_ENABLE: u64 = 0x800;
@@ -29,6 +34,7 @@ fn set_apic_base_enable(apic: PhysAddr) {
     cpu_set_msr(IA32_APIC_BASE_MSR, rax);
 }
 
+#[allow(dead_code)]
 fn set_apic_base_disable(apic: PhysAddr) {
     let rax = (apic.as_u64() & 0xfffff0000) & IA32_APIC_BASE_MSR_DISABLE;
     cpu_set_msr(IA32_APIC_BASE_MSR, rax);
@@ -37,22 +43,27 @@ fn set_apic_base_disable(apic: PhysAddr) {
 fn get_apic_base() -> PhysAddr {
     let mut value: u64 = 0;
     cpu_get_msr(IA32_APIC_BASE_MSR, &mut value);
+
     PhysAddr::new(value & 0xfffff0000)
 }
 
-fn write_apic_register(apic_base: &VirtAddr, reg: u8, value: u32) {
+fn write_apic_register(apic_base: &PhysAddr, reg: u64, value: u32) {
     let apic_base = apic_base.as_u64();
-    let reg_addr = (apic_base & 0xFFFFF0000) + reg as u64;
-    unsafe { *(reg_addr as *mut u32) = value };
+    let reg_addr = (apic_base & 0xFFFFF0000) + reg;
+
+    let virt_addr = unsafe { phys_to_virt(PhysAddr::new(reg_addr)) };
+
+    let phys_check =
+        OFFSET_PAGE_TABLE.get().unwrap().lock().translate(virt_addr);
+
+    unsafe { *(virt_addr.as_u64() as *mut u32) = value };
 }
 
-fn read_apic_register(apic_base: &VirtAddr, reg: u8) -> u32 {
+fn read_apic_register(apic_base: &PhysAddr, reg: u64) -> u32 {
     let apic_base = apic_base.as_u64();
-
-    serial_print!("got apic base");
-
-    let reg_addr = (apic_base & 0xFFFFF0000) + reg as u64;
-    unsafe { *(reg_addr as *const u32) }
+    let reg_addr = (apic_base & 0xFFFFF0000) + reg;
+    let virt_addr = unsafe { phys_to_virt(PhysAddr::new(reg_addr)) };
+    unsafe { *(virt_addr.as_u64() as *const u32) }
 }
 
 pub fn check_apic() -> bool {
@@ -64,39 +75,24 @@ pub fn check_apic() -> bool {
 unsafe fn phys_to_virt(phys: PhysAddr) -> VirtAddr {
     let phys = phys.as_u64();
     phys.checked_add(*PHYSICAL_MEMORY_OFFSET)
-        .map_or_else(|| panic!(" overflow"), VirtAddr::new)
+        .map_or_else(|| panic!("Overflow"), VirtAddr::new)
 }
 
 pub fn enable_apic() {
-    let mut mapper = OFFSET_PAGE_TABLE.get().unwrap().lock();
-    let mut frame_allocator = FRAME_ALLOCATOR.get().unwrap().lock();
+    let apic_base_physical_addr = get_apic_base();
+    set_apic_base_enable(apic_base_physical_addr);
 
-    let apic_phys_addr = get_apic_base();
-    set_apic_base_enable(apic_phys_addr);
-    // map virt address of apic
+    enable_timer();
 
-    let apic_virt = unsafe { phys_to_virt(apic_phys_addr) };
-    let page: Page<Size4KiB> = Page::containing_address(apic_virt);
-    let frame: PhysFrame<Size4KiB> = PhysFrame::containing_address(apic_phys_addr);
-    let flags: PageTableFlags = PageTableFlags::PRESENT | PageTableFlags::WRITABLE;
-
-    unsafe {
-        match mapper.map_to(page, frame, flags, &mut *frame_allocator) {
-            Ok(_) => {}
-            Err(why) => panic!("failed to map apic: {:?}", why),
-        }
-    }
-
-    // // FIXME: this causes a page fault
-    // // TODO: map to virtual memory
-
-    let reg = read_apic_register(&apic_virt, 0xF0);
-
-    serial_print!("ok2");
-
-    write_apic_register(&apic_virt, 0xF0, reg | 0x100);
+    write_apic_register(
+        &apic_base_physical_addr,
+        0xF0,
+        read_apic_register(&apic_base_physical_addr, 0xF0) | 0x1FF,
+    );
 }
 
-pub struct Apic {}
-
-pub enum ApicVector {}
+pub fn enable_timer() {
+    let apic_base = get_apic_base();
+    let current = read_apic_register(&apic_base, 0x320);
+    write_apic_register(&get_apic_base(), 0x320, (current & 0xFFFFFF00) | 0x20);
+}

kernel/src/arch/x86_64/cpu/msr.rs

@@ -1,3 +1,4 @@
+#![expect(unused)]
 use core::arch::x86_64::__cpuid;
 use spin::Lazy;
 use x86_64::registers::model_specific::Msr;

kernel/src/arch/x86_64/cpu/pic.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::missing_safety_doc)]
+
 use x86_64::instructions::port::Port;
 
 const CMD_INIT: u8 = 0x11;

kernel/src/arch/x86_64/drivers/ascii/mod.rs

@@ -1,15 +1,19 @@
-use core::fmt;
+use core::fmt::{self, Write};
 use spin::{Lazy, Mutex};
 use x86_64::instructions::interrupts;
 
-use crate::arch::x86_64::drivers::framebuffer::{colour::Colour, display::FRAMEBUFFER_WRITER};
+use crate::arch::x86_64::drivers::framebuffer::{
+    colour::Colour, display::FRAMEBUFFER_WRITER,
+};
 
 use crate::resources::font::{FONT_SPLEEN_8X16, Font};
+use crate::std::maths::geometry::Vec2;
 
 static FONT_WIDTH: u32 = 8;
 static FONT_HEIGHT: u32 = 16;
 
-pub static WRITER: Lazy<Mutex<Writer>> = Lazy::new(|| Mutex::new(Writer::new()));
+pub static WRITER: Lazy<Mutex<Writer>> =
+    Lazy::new(|| Mutex::new(Writer::new()));
 
 pub fn screensize_chars() -> (u32, u32) {
     let writer = WRITER.lock();
@@ -22,11 +26,8 @@ pub struct Writer {
     screen_width: u32,
     /// Measured in chars not pixels.
     screen_height: u32,
-    /// 16 pixels tall.
     text_line: u32,
-    /// 8 pixels wide.
     text_col: u32,
-
     fg_color: Colour,
     bg_color: Colour,
 }
@@ -59,6 +60,15 @@ impl Writer {
         self.font = font;
     }
 
+    pub const fn set_pos(&mut self, coords: Vec2<u32>) {
+        self.text_col = coords.x();
+        self.text_line = coords.y();
+    }
+
+    pub const fn pos(&self) -> Vec2<u32> {
+        Vec2::new(self.text_col, self.text_line)
+    }
+
     /// This is sent when the user types a backspace.
     const BACKSPACE: u8 = 8;
 
@@ -71,21 +81,31 @@ impl Writer {
             return;
         }
 
-        // Get the character data from the font array. -- each byte is a row of pixels
+        // Get the character data from the font array. -- each byte is a row of
+        // pixels
         let data: &[u8] = self.font.glyph_for(c as u16);
 
         if let Some(writer) = FRAMEBUFFER_WRITER.lock().as_mut() {
             for (row, line) in data.iter().enumerate().take(16) {
                 for col in 0..8 {
                     let pixel_x: u32 = self.text_col * FONT_WIDTH + col;
-                    let pixel_y: u32 = self.text_line * FONT_HEIGHT + row as u32;
+                    let pixel_y: u32 =
+                        self.text_line * FONT_HEIGHT + row as u32;
 
                     if line & (0x80 >> col) != 0 {
                         // Write the foreground color
-                        writer.write_pixel(pixel_x as usize, pixel_y as usize, self.fg_color);
+                        writer.write_pixel(
+                            pixel_x as usize,
+                            pixel_y as usize,
+                            self.fg_color,
+                        );
                     } else {
                         // Write the background color
-                        writer.write_pixel(pixel_x as usize, pixel_y as usize, self.bg_color);
+                        writer.write_pixel(
+                            pixel_x as usize,
+                            pixel_y as usize,
+                            self.bg_color,
+                        );
                     }
                 }
             }
@@ -117,8 +137,8 @@ impl Writer {
         }
     }
 
-    /// Handles the backspace character. TODO: Implement VT-100 style terminal control
-    /// codes alongside a shell. Not simple.
+    /// Handles the backspace character. TODO: Implement VT-100 style terminal
+    /// control codes alongside a shell. Not simple.
     pub fn backspace(&mut self) {
         if self.text_col > 0 {
             self.text_col -= 1;
@@ -193,6 +213,34 @@ pub fn clear_screen() {
     });
 }
 
+/// Prints a string at a given `coords` before returning to original position.
+///
+/// These are 0 based indices and refer to character position, not pixel
+/// positions.
+pub fn _print_oneshot(
+    fg: Colour,
+    bg: Colour,
+    coords: Vec2<u32>,
+    args: fmt::Arguments,
+) {
+    interrupts::without_interrupts(|| {
+        let mut writer = WRITER.lock();
+
+        // Save the old positions of `text_col` and `text_line`.
+        let old_pos = writer.pos();
+
+        // Also save the colors.
+        let old_fg_color = writer.fg_color;
+        let old_bg_color = writer.bg_color;
+
+        writer.set_pos(coords);
+        writer.set_colour(fg, bg);
+        writer.write_fmt(args).unwrap();
+        writer.set_colour(old_fg_color, old_bg_color);
+        writer.set_pos(old_pos);
+    });
+}
+
 pub fn reset_cursor() {
     interrupts::without_interrupts(|| {
         let mut writer = WRITER.lock();
@@ -201,6 +249,15 @@ pub fn reset_cursor() {
     });
 }
 
+#[macro_export]
+/// Prints a coloured string at a position before restoring previous position
+/// and colour.
+macro_rules! print_oneshot {
+    ($position:expr, $fg:expr, $bg:expr, $($arg:tt)*) => {
+        $crate::arch::x86_64::drivers::ascii::_print_oneshot($fg, $bg, $position, format_args!($($arg)*));
+    };
+}
+
 #[macro_export]
 macro_rules! println_log {
 	() => ($crate::print_log!("\n"));
@@ -224,12 +281,12 @@ macro_rules! print {
 }
 
 #[macro_export]
-macro_rules! printlnerr {
+macro_rules! eprintln {
     () => ($crate::printerr!("\n"));
-    ($($arg:tt)*) => ($crate::printerr!("{}\n", format_args!($($arg)*)));
+    ($($arg:tt)*) => ($crate::eprint!("{}\n", format_args!($($arg)*)));
 }
 
 #[macro_export]
-macro_rules! printerr {
+macro_rules! eprint {
     ($($arg:tt)*) => ($crate::prelude::_print_err(format_args!($($arg)*)));
 }

kernel/src/arch/x86_64/drivers/framebuffer/colour.rs

@@ -19,9 +19,14 @@ impl From<Colour> for u32 {
     fn from(val: Colour) -> Self {
         match val {
             Colour::ARGB(a, r, g, b) => {
-                (a as u32) << 24 | (r as u32) << 16 | (g as u32) << 8 | (b as u32)
+                (a as u32) << 24
+                    | (r as u32) << 16
+                    | (g as u32) << 8
+                    | (b as u32)
+            }
+            Colour::RGB(r, g, b) => {
+                ((r as u32) << 16) | (g as u32) << 8 | (b as u32)
             }
-            Colour::RGB(r, g, b) => ((r as u32) << 16) | (g as u32) << 8 | (b as u32),
             Colour::HexARGB(hex) => hex,
             Colour::Black => 0xFF000000,
             Colour::Blue => 0xFF0000FF,
@@ -38,7 +43,9 @@ impl From<Colour> for u32 {
 impl core::fmt::Display for Colour {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         match self {
-            Self::ARGB(r, g, b, a) => write!(f, "RGBA(#{:x}{:x}{:x}{:x})", r, g, b, a),
+            Self::ARGB(r, g, b, a) => {
+                write!(f, "RGBA(#{:x}{:x}{:x}{:x})", r, g, b, a)
+            }
             Self::RGB(r, g, b) => write!(f, "RGB(#{:x}{:x}{:x})", r, g, b),
             Self::HexARGB(hex) => write!(f, "Hex(#{:x})", hex),
             Self::Black => write!(f, "Black"),

kernel/src/arch/x86_64/drivers/framebuffer/display.rs

@@ -10,17 +10,19 @@ use core::panic;
 use limine::framebuffer::Framebuffer;
 use spin::{Lazy, Mutex};
 
-pub static FRAMEBUFFER_WRITER: Lazy<Mutex<Option<FramebufferWriter>>> = Lazy::new(|| {
-    Mutex::new(FRAMEBUFFER_REQUEST.get_response().map_or_else(
-        || {
-            panic!("Framebuffer request failed");
-        },
-        |framebuffer_response| {
-            let framebuffer = framebuffer_response.framebuffers().next().unwrap();
-            Some(FramebufferWriter::new(framebuffer))
-        },
-    ))
-});
+pub static FRAMEBUFFER_WRITER: Lazy<Mutex<Option<FramebufferWriter>>> =
+    Lazy::new(|| {
+        Mutex::new(FRAMEBUFFER_REQUEST.get_response().map_or_else(
+            || {
+                panic!("Framebuffer request failed");
+            },
+            |framebuffer_response| {
+                let framebuffer =
+                    framebuffer_response.framebuffers().next().unwrap();
+                Some(FramebufferWriter::new(framebuffer))
+            },
+        ))
+    });
 
 /// The updated writer stores necessary fields from the [Framebuffer].
 /// This ensures that the contained types are Send, as Framebuffer was
@@ -28,7 +30,8 @@ pub static FRAMEBUFFER_WRITER: Lazy<Mutex<Option<FramebufferWriter>>> = Lazy::ne
 ///
 /// It also avoids the requirement for lifetimes.
 ///
-/// Note this does not implement Writer as these functions only handle drawing pixels.
+/// Note this does not implement Writer as these functions only handle drawing
+/// pixels.
 pub struct FramebufferWriter {
     pitch: u64,
     bpp: u16,

kernel/src/arch/x86_64/drivers/keyboard.rs

@@ -6,20 +6,24 @@ use core::{
 use crate::println;
 use crossbeam::queue::ArrayQueue;
 use futures_util::{Stream, StreamExt, task::AtomicWaker};
-use pc_keyboard::{DecodedKey, HandleControl, KeyCode, Keyboard, ScancodeSet1, layouts::Uk105Key};
+use pc_keyboard::{
+    DecodedKey, HandleControl, KeyCode, Keyboard, ScancodeSet1,
+    layouts::Uk105Key,
+};
 use spin::{Lazy, Mutex, Once};
 
 static KBD_QUEUE: Once<ArrayQueue<u8>> = Once::new();
 static WAKER: AtomicWaker = AtomicWaker::new();
 
-pub static KEYBOARD: Lazy<Mutex<Keyboard<Uk105Key, ScancodeSet1>>> = Lazy::new(|| {
-    Mutex::new(Keyboard::new(
-        ScancodeSet1::new(),
-        // TODO: Expose an API to change the default KB layout.
-        Uk105Key,
-        HandleControl::Ignore,
-    ))
-});
+pub static KEYBOARD: Lazy<Mutex<Keyboard<Uk105Key, ScancodeSet1>>> =
+    Lazy::new(|| {
+        Mutex::new(Keyboard::new(
+            ScancodeSet1::new(),
+            // TODO: Expose an API to change the default KB layout.
+            Uk105Key,
+            HandleControl::Ignore,
+        ))
+    });
 pub static SCANCODE_STREAM: Lazy<Mutex<ScancodeStream>> =
     Lazy::new(|| Mutex::new(ScancodeStream::new()));
 
@@ -59,7 +63,10 @@ impl Default for ScancodeStream {
 impl Stream for ScancodeStream {
     type Item = u8;
 
-    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+    fn poll_next(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Self::Item>> {
         let queue = KBD_QUEUE.get().unwrap();
 
         if let Some(scancode) = queue.pop() {

kernel/src/arch/x86_64/interrupts.rs

@@ -1,9 +1,13 @@
-use crate::serial_print;
+use crate::{debug, serial_print};
 use pic8259::ChainedPics;
 use x86_64::registers::control::Cr2;
-use x86_64::structures::idt::{InterruptDescriptorTable, InterruptStackFrame, PageFaultErrorCode};
+use x86_64::structures::idt::{
+    InterruptDescriptorTable, InterruptStackFrame, PageFaultErrorCode,
+};
 use x86_64::structures::paging::mapper::MapperFlushAll;
-use x86_64::structures::paging::{FrameAllocator, Mapper, Page, PageTableFlags, Size4KiB};
+use x86_64::structures::paging::{
+    FrameAllocator, Mapper, Page, PageTableFlags, Size4KiB,
+};
 
 use super::gdt;
 use crate::arch::x86_64::memory::{FRAME_ALLOCATOR, OFFSET_PAGE_TABLE};
@@ -25,7 +29,8 @@ static IDT: Lazy<InterruptDescriptorTable> = Lazy::new(|| {
     idt.page_fault.set_handler_fn(page_fault_handler);
 
     idt[InterruptIndex::Timer.as_u8()].set_handler_fn(timer_interrupt_handler);
-    idt[InterruptIndex::Keyboard.as_u8()].set_handler_fn(keyboard_interrupt_handler);
+    idt[InterruptIndex::Keyboard.as_u8()]
+        .set_handler_fn(keyboard_interrupt_handler);
     idt
 });
 
@@ -90,19 +95,22 @@ extern "x86-interrupt" fn double_fault_handler(
     panic!("Exception: Double Fault\n{:#?}", stack_frame);
 }
 
-extern "x86-interrupt" fn keyboard_interrupt_handler(_stack_frame: InterruptStackFrame) {
+extern "x86-interrupt" fn keyboard_interrupt_handler(
+    _stack_frame: InterruptStackFrame,
+) {
     use pc_keyboard::{HandleControl, Keyboard, ScancodeSet1, layouts};
     // use pc_keyboard::DecodedKey;
     use spin::Mutex;
     use x86_64::instructions::port::Port;
 
-    static KEYBOARD: Lazy<Mutex<Keyboard<layouts::Uk105Key, ScancodeSet1>>> = Lazy::new(|| {
-        Mutex::new(Keyboard::new(
-            ScancodeSet1::new(),
-            layouts::Uk105Key,
-            HandleControl::Ignore,
-        ))
-    });
+    static KEYBOARD: Lazy<Mutex<Keyboard<layouts::Uk105Key, ScancodeSet1>>> =
+        Lazy::new(|| {
+            Mutex::new(Keyboard::new(
+                ScancodeSet1::new(),
+                layouts::Uk105Key,
+                HandleControl::Ignore,
+            ))
+        });
 
     let _keyboard = KEYBOARD.lock();
     let mut port = Port::new(0x60);
@@ -116,7 +124,10 @@ extern "x86-interrupt" fn keyboard_interrupt_handler(_stack_frame: InterruptStac
     }
 }
 
-extern "x86-interrupt" fn timer_interrupt_handler(_stack_frame: InterruptStackFrame) {
+extern "x86-interrupt" fn timer_interrupt_handler(
+    _stack_frame: InterruptStackFrame,
+) {
+    // debug!("Timer Interrupt");
     unsafe {
         PICS.lock()
             .notify_end_of_interrupt(InterruptIndex::Timer.as_u8());
@@ -127,17 +138,18 @@ extern "x86-interrupt" fn page_fault_handler(
     _stack_frame: InterruptStackFrame,
     _error_code: PageFaultErrorCode,
 ) {
-    serial_println!("Exception: Page Fault");
-    serial_println!("Accessed Address: {:?}", Cr2::read());
-    serial_println!("Error Code: {:?}", _error_code);
-    serial_println!("{:#?}", _stack_frame);
+    // serial_println!("Exception: Page Fault");
+    // serial_println!("Accessed Address: {:?}", Cr2::read());
+    // serial_println!("Error Code: {:?}", _error_code);
+    // serial_println!("{:#?}", _stack_frame);
 
     if let Some(frame_allocator) = FRAME_ALLOCATOR.get() {
         let mut f = frame_allocator.lock();
 
         let frame = f.allocate_frame().unwrap();
         let flags = PageTableFlags::PRESENT | PageTableFlags::WRITABLE;
-        let page: Page<Size4KiB> = Page::containing_address(Cr2::read().unwrap());
+        let page: Page<Size4KiB> =
+            Page::containing_address(Cr2::read().unwrap());
 
         unsafe {
             let mut mapper = OFFSET_PAGE_TABLE.get().unwrap().lock();

kernel/src/arch/x86_64/memory/allocation/heap_alloc.rs

@@ -1,21 +1,51 @@
+use crate::arch::x86_64::memory::allocation::page_alloc::FoundryOSFrameAllocator;
+use crate::arch::x86_64::memory::units::MemoryUnits;
+use crate::arch::x86_64::memory::{
+    FRAME_ALLOCATOR, HEAP_SIZE, HEAP_VIRTUAL_SPACE,
+};
+use crate::debugln;
 use core::alloc::{GlobalAlloc, Layout};
 use core::ptr;
 use spin::{Mutex, MutexGuard};
-use x86_64::structures::paging::{Size4KiB, mapper::MapToError};
+use x86_64::VirtAddr;
+use x86_64::structures::paging::{
+    PageTableFlags, Size4KiB, mapper::MapToError,
+};
 
-/// We are currently using a linked list heap allocator which uses our underlying page allocator.
+/// We are currently using a linked list heap allocator which uses our
+/// underlying page allocator.
 #[global_allocator]
-/// This is now Rust's global allocator, so we can use stuff requiring heap allocations.
-static ALLOCATOR: Locked<FoundryAllocator> = Locked::new(FoundryAllocator::new());
+/// This is now Rust's global allocator, so we can use stuff requiring heap
+/// allocations.
+static ALLOCATOR: Locked<FoundryAllocator> =
+    Locked::new(FoundryAllocator::new());
 
-pub const HEAP_START: usize = 0x4444_4444_0000;
-pub const HEAP_SIZE: usize = 1024 * 1024 * 1024;
-
-/// Sets up the heap using the backing page frame allocator.
+/// Initializes the heap.
+///
+/// This function must be called once, before any functions that
+/// require a heap are called. It sets up the heap by allocating
+/// the necessary frames from the page allocator. The heap is
+/// then ready for use.
+///
+/// # Safety
+///
+/// This function must be called only once, and must be called before any types
+/// are constructed that require dynamic memory allocation.
+///
+/// # Parameters
+///
+/// None
+///
+/// # Returns
+///
+/// Returns a `Result` containing a `MapToError` if the heap
+/// could not be initialized, or `Ok` if the heap was
+/// initialized successfully.
 pub unsafe fn init_heap() -> Result<(), MapToError<Size4KiB>> {
     unsafe {
-        // code to allocate frames is now done in the page fault interrupt handler!
-        ALLOCATOR.lock().init(HEAP_START, HEAP_SIZE);
+        // code to allocate frames is now done in the page fault interrupt
+        // handler!
+        ALLOCATOR.lock().init(HEAP_VIRTUAL_SPACE, HEAP_SIZE);
         Ok(())
     }
 }
@@ -36,7 +66,7 @@ impl<T> Locked<T> {
     }
 }
 
-const BLOCK_SIZES: &[usize] = &[8, 16, 32, 64, 128, 256, 512, 1024, 2048];
+const BLOCK_SIZES: &[usize] = &[8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096];
 
 struct ListNode {
     next: Option<&'static mut ListNode>,
@@ -61,7 +91,17 @@ impl FoundryAllocator {
             fallback: Locked::new(FoundryFallbackAllocator::new()),
         }
     }
+    /// Initializes the fallback allocator with the given heap start address and
+    /// size.
+    ///
+    /// # Safety
+    ///
+    /// This function is unsafe because it does not check whether the given heap
+    /// start address and size are valid.
     pub unsafe fn init(&mut self, heap_start: usize, heap_size: usize) {
+        debugln!("      => Start: {:?}", VirtAddr::new(heap_start as u64));
+        debugln!("      => Size: {}", MemoryUnits::from_bytes(heap_size));
+
         unsafe {
             self.fallback.lock().init(heap_start, heap_size);
         }
@@ -86,14 +126,18 @@ unsafe impl GlobalAlloc for Locked<FoundryAllocator> {
                 match allocator.list_heads[index].take() {
                     Some(node) => {
                         allocator.list_heads[index] = node.next.take();
-                        node as *mut ListNode as *mut u8
+                        let ptr = node as *mut ListNode as *mut u8;
+                        ensure_mapped(VirtAddr::new(ptr as u64));
+                        ptr
                     }
                     None => {
                         // no block exists in list => allocate new block
                         let block_size = BLOCK_SIZES[index];
                         // only works if all block sizes are a power of 2
                         let block_align = block_size;
-                        let layout = Layout::from_size_align(block_size, block_align).unwrap();
+                        let layout =
+                            Layout::from_size_align(block_size, block_align)
+                                .unwrap();
                         unsafe { allocator.fallback_alloc(layout) }
                     }
                 }
@@ -157,6 +201,12 @@ impl FoundryFallbackAllocator {
         }
     }
 
+    /// Initializes the allocator with a given heap start address and size.
+    ///
+    /// # Safety
+    ///
+    /// This function is unsafe because it does not check whether the given heap
+    /// start address and size are valid.
     pub unsafe fn init(&mut self, heap_start: usize, heap_size: usize) {
         unsafe { self.add_region(heap_start, heap_size) };
     }
@@ -165,6 +215,10 @@ impl FoundryFallbackAllocator {
         unsafe {
             let mut node = FallbackListNode::new(size);
             node.next = self.head.next.take();
+
+            let virt_addr = VirtAddr::new(addr as u64);
+            ensure_mapped(virt_addr);
+
             let node_ptr = addr as *mut FallbackListNode;
             node_ptr.write(node);
             self.head.next = Some(&mut *node_ptr);
@@ -179,7 +233,9 @@ impl FoundryFallbackAllocator {
         let mut current = &mut self.head;
         // look for a large enough memory region in linked list
         while let Some(ref mut region) = current.next {
-            if let Ok(alloc_start) = Self::alloc_from_region(region, size, align) {
+            if let Ok(alloc_start) =
+                Self::alloc_from_region(region, size, align)
+            {
                 // region suitable for allocation -> remove node from list
                 let next = region.next.take();
                 let ret = Some((current.next.take().unwrap(), alloc_start));
@@ -232,13 +288,16 @@ unsafe impl GlobalAlloc for Locked<FoundryFallbackAllocator> {
         // perform layout adjustments
         let (size, align) = FoundryFallbackAllocator::size_align(layout);
 
-        if let Some((region, alloc_start)) = allocator.find_region(size, align) {
+        if let Some((region, alloc_start)) = allocator.find_region(size, align)
+        {
             let alloc_end = alloc_start.checked_add(size).expect("overflow");
             let excess_size = region.end_addr() - alloc_end;
             if excess_size > 0 {
                 unsafe { allocator.add_region(alloc_end, excess_size) };
             }
-            alloc_start as *mut u8
+            let ptr = alloc_start as *mut u8;
+            ensure_mapped(VirtAddr::new(ptr as u64));
+            ptr
         } else {
             ptr::null_mut()
         }
@@ -249,7 +308,18 @@ unsafe impl GlobalAlloc for Locked<FoundryFallbackAllocator> {
 
         // perform layout adjustments
         let (size, _) = FoundryFallbackAllocator::size_align(layout);
-
         unsafe { allocator.add_region(ptr as usize, size) }
     }
 }
+
+fn ensure_mapped(virt_addr: VirtAddr) {
+    if !FoundryOSFrameAllocator::is_mapped(virt_addr) {
+        let mut foundry_alloc = FRAME_ALLOCATOR.get().unwrap().lock();
+        foundry_alloc
+            .allocate_page(
+                virt_addr,
+                PageTableFlags::PRESENT | PageTableFlags::WRITABLE,
+            )
+            .unwrap();
+    }
+}

kernel/src/arch/x86_64/memory/allocation/mod.rs

@@ -1,2 +1,3 @@
 pub mod heap_alloc;
+pub(crate) mod page_alloc;
 pub mod stack_alloc;

kernel/src/arch/x86_64/memory/allocation/page_alloc.rs

@@ -0,0 +1,102 @@
+use crate::arch::x86_64::memory::{FRAME_ALLOCATOR, OFFSET_PAGE_TABLE};
+use limine::memory_map::EntryType;
+use limine::response::MemoryMapResponse;
+use spin::Mutex;
+use x86_64::structures::paging::mapper::{MapToError, TranslateResult};
+use x86_64::structures::paging::{
+    FrameAllocator, Mapper, Page, PageTableFlags, PhysFrame, Size4KiB,
+    Translate,
+};
+use x86_64::{PhysAddr, VirtAddr};
+
+pub struct FoundryOSFrameAllocator {
+    memory_map: &'static MemoryMapResponse,
+    next: usize,
+}
+
+impl FoundryOSFrameAllocator {
+    /// Creates a new `FoundryOSFrameAllocator` from a memory map.
+    ///
+    /// This function takes a reference to a `MemoryMapResponse` and initializes
+    /// a `FoundryOSFrameAllocator` with it. The `next` field is set to 0,
+    /// indicating that the first frame to be allocated is the first frame
+    /// in the memory map.
+    pub fn init(memory_map: &'static MemoryMapResponse) {
+        FRAME_ALLOCATOR.call_once(|| {
+            Mutex::new(Self {
+                memory_map,
+                next: 0,
+            })
+        });
+    }
+
+    pub fn count_usable_frames(&self) -> u64 {
+        self.usable_frames().count() as u64
+    }
+
+    pub fn available_memory(&self) -> u64 {
+        self.memory_map
+            .entries()
+            .iter()
+            .map(|region| region.base..region.base + region.length)
+            .flat_map(|r| r.step_by(4096))
+            .count() as u64
+            * 4096
+    }
+
+    /// An iterator over all usable frames in the memory map.
+    ///
+    /// Yields one `PhysFrame` for each available 4KiB frame in the memory map.
+    ///
+    /// This function is used to allocate frames for the page map.
+    fn usable_frames(&self) -> impl Iterator<Item = PhysFrame> + use<> {
+        let regions = self.memory_map.entries().iter();
+        let usable_regions =
+            regions.filter(|region| region.entry_type == EntryType::USABLE);
+        let addr_ranges = usable_regions
+            .map(|region| region.base..region.base + region.length);
+        let frame_addresses = addr_ranges.flat_map(|r| r.step_by(4096));
+        frame_addresses.map(|addr| {
+            PhysFrame::from_start_address(PhysAddr::new(addr)).unwrap()
+        })
+    }
+
+    pub(crate) fn is_mapped(virt_addr: VirtAddr) -> bool {
+        let mapper = OFFSET_PAGE_TABLE.get().unwrap().lock();
+        matches!(mapper.translate(virt_addr), TranslateResult::Mapped { .. })
+    }
+
+    pub(crate) fn allocate_page(
+        &mut self,
+        start_addr: VirtAddr,
+        flags: PageTableFlags,
+    ) -> Result<(), MapToError<Size4KiB>> {
+        let page = Page::containing_address(start_addr);
+        let frame = self
+            .allocate_frame()
+            .ok_or(MapToError::<Size4KiB>::FrameAllocationFailed)?;
+        let mut mapper = OFFSET_PAGE_TABLE.get().unwrap().lock();
+
+        unsafe { mapper.map_to(page, frame, flags, self)? }.flush();
+
+        Ok(())
+    }
+}
+
+unsafe impl FrameAllocator<Size4KiB> for FoundryOSFrameAllocator {
+    /// Allocates a frame from the list of usable frames.
+    ///
+    /// This function returns the next available `PhysFrame` from the memory
+    /// map, if one exists. Once a frame is allocated, the internal counter
+    /// is incremented to point to the next frame for future allocations.
+    ///
+    /// # Returns
+    ///
+    /// - `Some(PhysFrame)`: If a usable frame is available.
+    /// - `None`: If there are no more usable frames to allocate.
+    fn allocate_frame(&mut self) -> Option<PhysFrame> {
+        let frame = self.usable_frames().nth(self.next);
+        self.next += 1;
+        frame
+    }
+}

kernel/src/arch/x86_64/memory/allocation/stack_alloc.rs

@@ -1,42 +1,69 @@
-use x86_64::structures::paging::{mapper, FrameAllocator, Mapper, Page, Size4KiB};
+use crate::arch::x86_64::memory::STACK_VIRTUAL_SPACE;
 use x86_64::VirtAddr;
+use x86_64::structures::paging::{
+    FrameAllocator, Mapper, Page, Size4KiB, mapper,
+};
 
 fn reserve_stack_memory(size_in_pages: u64) -> Page {
     use core::sync::atomic::{AtomicU64, Ordering};
-    static STACK_ALLOC_NEXT: AtomicU64 = AtomicU64::new(0x_5555_5555_0000);
-    let start_addr = VirtAddr::new(STACK_ALLOC_NEXT.fetch_add(
-        size_in_pages * Page::<Size4KiB>::SIZE,
-        Ordering::Relaxed,
-    ));
+    static STACK_ALLOC_NEXT: AtomicU64 =
+        AtomicU64::new(STACK_VIRTUAL_SPACE as u64);
+    let start_addr =
+        VirtAddr::new(STACK_ALLOC_NEXT.fetch_add(
+            size_in_pages * Page::<Size4KiB>::SIZE,
+            Ordering::Relaxed,
+        ));
     Page::from_start_address(start_addr)
         .expect("`STACK_ALLOC_NEXT` not page aligned")
 }
 
+/// Allocates a stack in the virtual address space, mapped to physical pages.
+///
+/// This function allocates a stack in the virtual address space, mapped to
+/// physical pages. The stack is allocated as a sequence of pages, with the
+/// first page allocated as a guard page. The stack is then mapped to the
+/// allocated physical frame.
+///
+/// The function takes the size of the stack in pages, a mutable reference to a
+/// mapper, and a mutable reference to a frame allocator. It returns a `Result`
+/// containing a `StackBounds` struct, which contains the start and end virtual
+/// addresses of the allocated stack.
+///
+/// # Safety
+///
+/// This function is unsafe because it maps physical frames to virtual addresses
+/// without any protection. This can lead to bugs if the physical frames are not
+/// correctly allocated, or if the virtual addresses are not correctly aligned.
+///
+/// # Panics
+///
+/// This function will panic if the allocation of the physical frame fails.
 pub unsafe fn alloc_stack(
     size_in_pages: u64,
     mapper: &mut impl Mapper<Size4KiB>,
     frame_allocator: &mut impl FrameAllocator<Size4KiB>,
-) -> Result<StackBounds, mapper::MapToError<Size4KiB>> { unsafe {
-    use x86_64::structures::paging::PageTableFlags as Flags;
+) -> Result<StackBounds, mapper::MapToError<Size4KiB>> {
+    unsafe {
+        use x86_64::structures::paging::PageTableFlags as Flags;
 
-    let guard_page = reserve_stack_memory(size_in_pages + 1);
-    let stack_start = guard_page + 1;
-    let stack_end = stack_start + size_in_pages;
+        let guard_page = reserve_stack_memory(size_in_pages + 1);
+        let stack_start = guard_page + 1;
+        let stack_end = stack_start + size_in_pages;
 
-    for page in Page::range(stack_start, stack_end) {
-        let frame = frame_allocator
-            .allocate_frame()
-            .ok_or(mapper::MapToError::FrameAllocationFailed)?;
-        let flags = Flags::PRESENT | Flags::WRITABLE;
-        mapper.map_to(page, frame, flags, frame_allocator)?.flush();
+        for page in Page::range(stack_start, stack_end) {
+            let frame = frame_allocator
+                .allocate_frame()
+                .ok_or(mapper::MapToError::FrameAllocationFailed)?;
+            let flags = Flags::PRESENT | Flags::WRITABLE;
+            mapper.map_to(page, frame, flags, frame_allocator)?.flush();
+        }
+
+        Ok(StackBounds {
+            start: stack_start.start_address(),
+            end: stack_end.start_address(),
+        })
     }
-
-    Ok(StackBounds {
-        start: stack_start.start_address(),
-        end: stack_end.start_address(),
-    })
-}}
-
+}
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
 pub struct StackBounds {

kernel/src/arch/x86_64/memory/mapping.rs

@@ -16,7 +16,8 @@ static HIGHER_HALF_DIRECT_MAP_REQUEST: HhdmRequest = HhdmRequest::new();
 
 #[used]
 #[unsafe(link_section = ".requests")]
-static KERNEL_ADDRESS_REQUEST: KernelAddressRequest = KernelAddressRequest::new();
+pub static KERNEL_ADDRESS_REQUEST: KernelAddressRequest =
+    KernelAddressRequest::new();
 
 /// ```rs
 /// let virt_addr = phys_addr + offset;

kernel/src/arch/x86_64/memory/mod.rs

@@ -1,17 +1,25 @@
 pub mod allocation;
-pub mod memory_map;
+pub mod mapping;
+pub mod units;
 
-// use lib_alloc::allocator::FoundryAllocator;
-use limine::{memory_map::EntryType, response::MemoryMapResponse};
+use allocation::page_alloc::FoundryOSFrameAllocator;
 use spin::{Mutex, Once};
+use units::MemoryUnits::*;
 use x86_64::{
-    PhysAddr, VirtAddr,
+    VirtAddr,
     registers::control::Cr3,
-    structures::paging::{FrameAllocator, OffsetPageTable, PageTable, PhysFrame, Size4KiB},
+    structures::paging::{OffsetPageTable, PageTable},
 };
 
+/// Start address of the memory space where we store allocated stacks.
+pub const STACK_VIRTUAL_SPACE: usize = 0x5555_5555_0000;
+/// Start address of heap allocated memory.
+pub const HEAP_VIRTUAL_SPACE: usize = 0x4444_4444_0000;
+pub const HEAP_SIZE: usize = MiB(1).to_bytes();
+
 pub static FRAME_ALLOCATOR: Once<Mutex<FoundryOSFrameAllocator>> = Once::new();
 pub static OFFSET_PAGE_TABLE: Once<Mutex<OffsetPageTable>> = Once::new();
+
 /// Returns a mutable reference to the current level 4 page table.
 ///
 /// # Safety
@@ -19,7 +27,9 @@ pub static OFFSET_PAGE_TABLE: Once<Mutex<OffsetPageTable>> = Once::new();
 /// The caller must ensure that the level 4 page table is not modified
 /// simultaneously. The caller must also ensure that the physical memory offset
 /// is correct, to ensure that the correct virtual address is constructed.
-unsafe fn active_l4_table(physical_memory_offset: VirtAddr) -> &'static mut PageTable {
+unsafe fn active_l4_table(
+    physical_memory_offset: VirtAddr,
+) -> &'static mut PageTable {
     let (level_4_frame, _) = Cr3::read();
 
     let phys_addr = level_4_frame.start_address();
@@ -48,102 +58,8 @@ unsafe fn active_l4_table(physical_memory_offset: VirtAddr) -> &'static mut Page
 pub fn init_page_table(physical_memory_offset: VirtAddr) {
     unsafe {
         let l4_table = active_l4_table(physical_memory_offset);
-        let offset_table = OffsetPageTable::new(l4_table, physical_memory_offset);
+        let offset_table =
+            OffsetPageTable::new(l4_table, physical_memory_offset);
         OFFSET_PAGE_TABLE.call_once(|| Mutex::new(offset_table));
     }
 }
-
-pub struct FoundryOSFrameAllocator {
-    memory_map: &'static MemoryMapResponse,
-    next: usize,
-}
-
-pub fn init_frame_allocator(memory_map: &'static MemoryMapResponse) {
-    unsafe {
-        FRAME_ALLOCATOR.call_once(|| Mutex::new(FoundryOSFrameAllocator::init(memory_map)));
-    }
-}
-
-impl FoundryOSFrameAllocator {
-    /// Creates a new `FoundryOSFrameAllocator` from a memory map.
-    ///
-    /// This function takes a reference to a `MemoryMapResponse` and initializes a
-    /// `FoundryOSFrameAllocator` with it. The `next` field is set to 0, indicating that
-    /// the first frame to be allocated is the first frame in the memory map.
-    pub const unsafe fn init(memory_map: &'static MemoryMapResponse) -> Self {
-        Self {
-            memory_map,
-            next: 0,
-        }
-    }
-
-    pub fn count_usable_frames(&self) -> u32 {
-        self.usable_frames().count() as u32
-    }
-
-    /// An iterator over all usable frames in the memory map.
-    ///
-    /// Yields one `PhysFrame` for each available 4KiB frame in the memory map.
-    ///
-    /// This function is used to allocate frames for the pagemap.
-    fn usable_frames(&self) -> impl Iterator<Item = PhysFrame> + use<> {
-        let regions = self.memory_map.entries().iter();
-        let usable_regions = regions.filter(|region| region.entry_type == EntryType::USABLE);
-
-        let addr_ranges = usable_regions.map(|region| region.base..region.base + region.length);
-
-        let frame_addresses = addr_ranges.flat_map(|r| r.step_by(4096));
-
-        frame_addresses.map(|addr| PhysFrame::from_start_address(PhysAddr::new(addr)).unwrap())
-    }
-}
-
-unsafe impl FrameAllocator<Size4KiB> for FoundryOSFrameAllocator {
-    /// Allocates a frame from the list of usable frames.
-    ///
-    /// This function returns the next available `PhysFrame` from the memory map,
-    /// if one exists. Once a frame is allocated, the internal counter is incremented
-    /// to point to the next frame for future allocations.
-    ///
-    /// # Returns
-    ///
-    /// - `Some(PhysFrame)`: If a usable frame is available.
-    /// - `None`: If there are no more usable frames to allocate.
-    fn allocate_frame(&mut self) -> Option<PhysFrame> {
-        let frame = self.usable_frames().nth(self.next);
-        self.next += 1;
-        frame
-    }
-}
-
-// pub unsafe fn translate_addr(addr: VirtAddr, physical_memory_offset: VirtAddr) -> Option<PhysAddr> {
-//     translate_addr_inner(addr, physical_memory_offset)
-// }
-
-// fn translate_addr_inner(addr: VirtAddr, physical_memory_offset: VirtAddr) -> Option<PhysAddr> {
-//     let (l4_table_frame, _) = Cr3::read();
-
-//     let table_indexes = [
-//         addr.p4_index(),
-//         addr.p3_index(),
-//         addr.p2_index(),
-//         addr.p1_index(),
-//     ];
-//     let mut frame = l4_table_frame;
-
-//     for &i in &table_indexes {
-//         let virt = physical_memory_offset + frame.start_address().as_u64();
-//         let table_ptr: *const PageTable = virt.as_ptr();
-//         let table = unsafe { &*table_ptr };
-
-//         let entry = &table[i];
-
-//         frame = match entry.frame() {
-//             Ok(frame) => frame,
-//             Err(FrameError::FrameNotPresent) => return None,
-//             Err(FrameError::HugeFrame) => panic!("huge frames are not supported!"),
-//         };
-//     }
-
-//     Some(frame.start_address() + u64::from(addr.page_offset()))
-// }

kernel/src/arch/x86_64/memory/units.rs

@@ -0,0 +1,49 @@
+pub enum MemoryUnits {
+    B(usize),
+    KiB(usize),
+    MiB(usize),
+    GiB(usize),
+}
+
+impl MemoryUnits {
+    pub const fn to_bytes(&self) -> usize {
+        match self {
+            Self::B(b) => *b,
+            Self::KiB(kib) => *kib * 1024,
+            Self::MiB(mib) => *mib * 1024 * 1024,
+            Self::GiB(gib) => *gib * 1024 * 1024 * 1024,
+        }
+    }
+
+    pub const fn from_bytes(bytes: usize) -> Self {
+        if bytes < 1024 {
+            Self::B(bytes)
+        } else if bytes < 1024 * 1024 {
+            Self::KiB(bytes / 1024)
+        } else if bytes < 1024 * 1024 * 1024 {
+            Self::MiB(bytes / (1024 * 1024))
+        } else {
+            Self::GiB(bytes / (1024 * 1024 * 1024))
+        }
+    }
+
+    pub const fn convert(&mut self) {
+        match self {
+            Self::B(b) if *b > 1024 => *self = Self::KiB(*b / 1024),
+            Self::KiB(kib) if *kib > 1024 => *self = Self::MiB(*kib / 1024),
+            Self::MiB(mib) if *mib > 1024 => *self = Self::GiB(*mib / 1024),
+            _ => (),
+        }
+    }
+}
+
+impl core::fmt::Display for MemoryUnits {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Self::B(b) => write!(f, "{} B", b),
+            Self::KiB(kib) => write!(f, "{} KiB", kib),
+            Self::MiB(mib) => write!(f, "{} MiB", mib),
+            Self::GiB(gib) => write!(f, "{} GiB", gib),
+        }
+    }
+}

kernel/src/arch/x86_64/processing/async_io/task.rs

@@ -2,7 +2,6 @@
 //!
 //! Written by @zxq5 for the most part with code from
 //! [here](https://github.com/phil-opp/blog_os/).
-//!
 
 use alloc::boxed::Box;
 use alloc::collections::BTreeMap;
@@ -81,9 +80,9 @@ impl Executor {
                 Some(task) => task,
                 None => continue, // task no longer exists
             };
-            let waker = waker_cache
-                .entry(task_id)
-                .or_insert_with(|| TaskWaker::new_waker(task_id, task_queue.clone()));
+            let waker = waker_cache.entry(task_id).or_insert_with(|| {
+                TaskWaker::new_waker(task_id, task_queue.clone())
+            });
             let mut context = Context::from_waker(waker);
             match task.poll(&mut context) {
                 Poll::Ready(()) => {
@@ -129,7 +128,10 @@ impl TaskWaker {
         self.task_queue.push(self.task_id).expect("task_queue full");
     }
 
-    fn new_waker(task_id: TaskId, task_queue: Arc<ArrayQueue<TaskId>>) -> Waker {
+    fn new_waker(
+        task_id: TaskId,
+        task_queue: Arc<ArrayQueue<TaskId>>,
+    ) -> Waker {
         Waker::from(Arc::new(Self {
             task_id,
             task_queue,

kernel/src/arch/x86_64/processing/mod.rs

@@ -1,2 +1,4 @@
+#![expect(unused)]
 pub mod async_io;
+mod taskrunner;
 pub mod threading;

kernel/src/arch/x86_64/processing/taskrunner/mod.rs

@@ -0,0 +1,12 @@
+use alloc::boxed::Box;
+
+pub struct Task {
+    pid: usize,
+    task: Box<dyn Fn() + Send + 'static>,
+}
+
+impl Task {
+    // pub const fn new() {}
+
+    pub const fn run() {}
+}

kernel/src/arch/x86_64/processing/threading/mod.rs

@@ -1,5 +1,5 @@
-use x86_64::VirtAddr;
 use crate::arch::x86_64::memory::allocation::stack_alloc::StackBounds;
+use x86_64::VirtAddr;
 
 mod switch;
 
@@ -10,8 +10,6 @@ pub struct Thread {
     stack_bounds: Option<StackBounds>,
 }
 
-
-
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
 pub struct ThreadId(u64);
 

kernel/src/lib.rs

@@ -1,5 +1,5 @@
 #![no_std]
-#![feature(abi_x86_interrupt)]
+#![feature(abi_x86_interrupt, breakpoint)]
 #![warn(
     clippy::correctness,
     clippy::nursery,
@@ -12,44 +12,52 @@
 )]
 
 extern crate alloc;
+
 use crate::{
-    arch::x86_64::memory::{init_frame_allocator, init_page_table},
+    arch::x86_64::{
+        // cpu::apic::enable_apic,
+        drivers::{
+            ascii::screensize_chars, framebuffer::display::screensize_px,
+        },
+        gdt,
+        interrupts,
+        memory::{
+            FRAME_ALLOCATOR,
+            allocation::{
+                heap_alloc::init_heap, page_alloc::FoundryOSFrameAllocator,
+            },
+            init_page_table, mapping,
+            units::MemoryUnits,
+        },
+    },
     prelude::*,
 };
-use arch::x86_64::memory::allocation::heap_alloc::init_heap;
-use arch::x86_64::memory::memory_map;
+
+use alloc::{boxed::Box, format};
 use core::arch::asm;
 use limine::BaseRevision;
 use x86_64::VirtAddr;
 
 pub mod arch;
+/// Commonly used re-exports.
+pub mod prelude;
 pub mod resources;
-#[allow(unused)] // We aren't using much of this right now.
+// We aren't using much of this right now.
+#[allow(unused)]
 pub mod std;
+mod step;
 pub mod util;
 
-pub mod prelude {
-    pub use crate::std::io::{_print, _print_log, _serial_write};
-    pub use crate::{
-        print, print_log, printerr, println, println_log, printlnerr, serial_print, serial_println,
-    };
-}
-
 /// Sets the base revision to the latest revision supported by the crate.
 /// See specification for further info.
-/// Be sure to mark all limine requests with #[used], otherwise they may be removed by the compiler.
+/// Be sure to mark all limine requests with #[used], otherwise they may be
+/// removed by the compiler.
 #[used]
-// The .requests section allows limine to find the requests faster and more safely.
+// The .requests section allows limine to find the requests faster and more
+// safely.
 #[unsafe(link_section = ".requests")]
 static BASE_REVISION: BaseRevision = BaseRevision::new();
 
-#[panic_handler]
-fn rust_panic(_info: &core::panic::PanicInfo) -> ! {
-    println!("Kernel panic: {}", _info);
-    serial_println!("Kernel panic: {}", _info);
-    hcf();
-}
-
 pub fn hcf() -> ! {
     loop {
         unsafe {
@@ -59,60 +67,95 @@ pub fn hcf() -> ! {
     }
 }
 
-pub fn boot() -> Result<(), &'static str> {
+#[derive(Debug)]
+pub struct NoError {}
+
+impl core::fmt::Display for NoError {
+    fn fmt(&self, _f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        Ok(())
+    }
+}
+
+pub struct NoTags;
+
+impl core::error::Error for NoError {}
+
+/// Panicking before this is initialised is unwise. We should probably extract
+/// very early init into it's own function because Stack Traces may require
+/// allocations etc.
+#[inline(never)]
+pub fn boot() -> Result<(), Box<dyn core::error::Error>> {
     if !BASE_REVISION.is_supported() {
-        return Err("base revision not supported");
+        return Err("Base revision not supported.".into());
     }
 
-    use arch::x86_64::{gdt, interrupts};
-
-    let memory_map = memory_map::get_memory_map();
+    let memory_map = mapping::get_memory_map();
 
     print_log!("    Initialising Serial... ");
-    if arch::x86_64::drivers::serial::init().is_err() {
-        println_log!("[Not Detected]")
+    let res = arch::x86_64::drivers::serial::init();
+    serial_print!("    Initialising Serial... ");
+    if res.is_err() {
+        debugln!("[Not Detected]")
     } else {
-        println_log!("[Success]");
+        debugln!("[Success]");
     }
 
-    print_log!("    Setting Up Global Descriptor Table... ");
+    debugln!(
+        "Display is {:?} chars, {:?} px.",
+        screensize_chars(),
+        screensize_px()
+    );
+
+    debug!("    Setting Up Global Descriptor Table... ");
     gdt::init();
-    println_log!("[Success]");
+    debugln!("[Success]");
 
-    print_log!("    Setting Up Interrupt Descriptor Table... ");
+    debug!("    Setting Up Interrupt Descriptor Table... ");
     interrupts::init_idt();
-    println_log!("[Success]");
+    debugln!("[Success]");
 
-    print_log!("    Initialising Memory Subsystem... ");
-    let physical_memory_offset = VirtAddr::new(*memory_map::PHYSICAL_MEMORY_OFFSET);
+    debugln!("    Initialising Memory Subsystem... ");
+    let physical_memory_offset =
+        VirtAddr::new(*mapping::PHYSICAL_MEMORY_OFFSET);
     init_page_table(physical_memory_offset);
-    println_log!("[Success]");
+    FoundryOSFrameAllocator::init(memory_map);
+    let available_bytes =
+        FRAME_ALLOCATOR.get().unwrap().lock().available_memory();
 
-    print_log!("    Setting Up Page Table... ");
-    init_frame_allocator(memory_map);
-    println_log!("[Success]");
+    debugln!(
+        "      => Available Memory: {}",
+        MemoryUnits::from_bytes(available_bytes as usize)
+    );
 
-    print_log!("    Initialising Heap... ");
-    if unsafe { init_heap() }.is_err() {
-        return Err("Failed to initialise heap: error");
+    // Allocations should be all fine past this point.
+    debugln!("    Initialising Heap... ");
+    match unsafe { init_heap() } {
+        Ok(_) => debugln!("    [Success]"),
+        Err(why) => return Err(format!("{:?}", why).into()),
     }
-    println_log!("[Success]");
 
-    print_log!("    Enabling PICs... ");
+    debug!("    Enabling PICs... ");
     interrupts::enable_pic();
-    println_log!("[Success]");
+    debugln!("[Success]");
 
-    // print_log!("    Disabling PICs... ");
+    // debug!("    Disabling PICs... ");
     // interrupts::disable_pic();
-    // println_log!("[Success]");
+    // debugln!("[Success]");
 
-    // print_log!("    Initialising APIC");
+    // debug!("    Initialising APIC... ");
     // enable_apic();
-    // println_log!("[Success]");
+    // debugln!("[Success]");
 
-    print_log!("    Enabling Interrupts... ");
+    debug!("    Enabling Interrupts... ");
     x86_64::instructions::interrupts::enable();
-    println_log!("[Success]");
+    debugln!("[Success]");
 
     Ok(())
 }
+
+#[panic_handler]
+fn panic(_info: &core::panic::PanicInfo<'_>) -> ! {
+    debugln!("{:?}", _info);
+
+    hcf()
+}

kernel/src/main.rs

@@ -2,11 +2,12 @@
 #![no_main]
 
 extern crate alloc;
-use foundry_os::arch::x86_64::drivers::ascii::screensize_chars;
-use foundry_os::arch::x86_64::drivers::framebuffer::display::screensize_px;
-use foundry_os::arch::x86_64::processing::async_io::task::{Executor, Task};
-use foundry_os::util::shell::shell;
-use foundry_os::{println, println_log};
+
+use foundry_os::{
+    arch::x86_64::processing::async_io::task::{Executor, Task},
+    prelude::*,
+    util::shell::shell,
+};
 
 #[unsafe(no_mangle)]
 extern "C" fn kmain() -> ! {
@@ -14,14 +15,7 @@ extern "C" fn kmain() -> ! {
     if let Err(err) = foundry_os::boot() {
         panic!("{}", err);
     }
-
-    println_log!("[ Kernel Initialised Successfully ] ");
-
-    let dimensions = screensize_chars();
-    let dimensions2 = screensize_px();
-
-    println!("Dimensions: {}x{} (px)", dimensions2.0, dimensions2.1);
-    println!("Dimensions: {}x{} (chars)", dimensions.0, dimensions.1);
+    println_log!(" [ Kernel Initialised Successfully ] ");
 
     // println!("TESTING :: Allocation");
     // let somevec = vec![0; 1_000_000];
@@ -29,6 +23,8 @@ extern "C" fn kmain() -> ! {
     // println!("{}", somevec.len());
     // println!("PASSED!");
 
+    // test1();
+
     let mut executor = Executor::new();
     executor.spawn(Task::new(shell()));
     executor.run()

kernel/src/prelude.rs

@@ -0,0 +1,7 @@
+pub use crate::{
+    arch::x86_64::drivers::framebuffer::colour::Colour,
+    debug, debugln, eprint, eprintln, hcf, print, print_log, print_oneshot,
+    println, println_log, serial_print, serial_println,
+    std::debug::_debug,
+    std::io::{_print, _print_err, _print_log, _serial_write},
+};

kernel/src/resources/font/mod.rs

@@ -1,8 +1,8 @@
 use libm::include_font;
-pub static FONT_SPLEEN_8X16: Font =
+pub const FONT_SPLEEN_8X16: Font =
     Font::new(include_font!("../../../resources/font/spleen-8x16.psf"));
 
-pub static FONT_CP850_8X16: Font =
+pub const FONT_CP850_8X16: Font =
     Font::new(include_font!("../../../resources/font/cp850-8x16.psf"));
 
 // pub struct Font(pub [[u8; 16]; 512]);
@@ -39,8 +39,10 @@ impl Font {
     pub const fn height(&self) -> usize {
         self.height
     }
+}
 
-    pub fn default() -> &'static Self {
-        &FONT_CP850_8X16
+impl Default for Font {
+    fn default() -> Self {
+        FONT_CP850_8X16
     }
 }

kernel/src/std/application.rs

@@ -8,7 +8,10 @@ pub mod window;
 pub trait Application {
     type Output;
 
-    async fn run(&mut self, args: Vec<String>) -> Result<Self::Output, Error>;
+    fn run(
+        &mut self,
+        args: Vec<String>,
+    ) -> impl Future<Output = Result<Self::Output, Error>> + Send;
 }
 
 #[derive(Debug)]

kernel/src/std/application/frame.rs

@@ -11,20 +11,31 @@ pub struct Frame<'f> {
 impl<'a> Frame<'a> {
     pub fn new(window: &'a Window) -> Self {
         Self {
-            data: vec![vec![Colour::Black; window.dimensions().x()]; window.dimensions().y()],
+            data: vec![
+                vec![Colour::Black; window.dimensions().x()];
+                window.dimensions().y()
+            ],
             window,
         }
     }
 
     pub fn render(&self) -> Result<(), RenderError> {
-        let data: Vec<&[Colour]> = self.data.iter().map(|v| v.as_slice()).collect::<Vec<_>>();
+        let data: Vec<&[Colour]> =
+            self.data.iter().map(|v| v.as_slice()).collect::<Vec<_>>();
         self.window
             .render(data.as_slice())
             .map_err(|_| RenderError::Generic)
     }
 
-    pub fn write_pixel(&mut self, x: usize, y: usize, color: Colour) -> Result<(), RenderError> {
-        if x >= self.window.dimensions().x() || y >= self.window.dimensions().y() {
+    pub fn write_pixel(
+        &mut self,
+        x: usize,
+        y: usize,
+        color: Colour,
+    ) -> Result<(), RenderError> {
+        if x >= self.window.dimensions().x()
+            || y >= self.window.dimensions().y()
+        {
             return Err(RenderError::Generic);
         }
         self.data[y][x] = color;

kernel/src/std/application/window.rs

@@ -24,7 +24,8 @@ impl Window {
     }
 
     pub fn render(&self, _data: &[&[Colour]]) -> Result<(), RenderError> {
-        // TODO: error handling!! the kernel should return an error in some cases
+        // TODO: error handling!! the kernel should return an error in some
+        // cases
         if let Some(fb) = FRAMEBUFFER_WRITER.lock().as_mut() {
             fb.render_frame(_data);
         }

kernel/src/std/ascii.rs

@@ -46,7 +46,11 @@ impl<'a> Writer<'a> {
                 if line & (0x80 >> col) != 0 {
                     for i in 0..scale {
                         for j in 0..scale {
-                            frame.write_pixel(pixel_x + i, pixel_y + j, Colour::White)?;
+                            frame.write_pixel(
+                                pixel_x + i,
+                                pixel_y + j,
+                                Colour::White,
+                            )?;
                         }
                     }
                 }

kernel/src/std/debug.rs

@@ -0,0 +1,21 @@
+use crate::prelude::{_print_log, _serial_write};
+use core::fmt;
+use x86_64::instructions::interrupts;
+
+#[macro_export]
+macro_rules! debugln {
+	() => ($crate::print_log!("\n"));
+	($($arg:tt)*) => ($crate::debug!("{}\n", format_args!($($arg)*)));
+}
+
+#[macro_export]
+macro_rules! debug {
+	($($arg:tt)*) => ($crate::prelude::_debug(format_args!($($arg)*)));
+}
+
+pub fn _debug(args: fmt::Arguments) {
+    interrupts::without_interrupts(|| {
+        _print_log(args);
+        _serial_write(args);
+    });
+}

kernel/src/std/elf/mod.rs

@@ -0,0 +1,168 @@
+//! Basic ELF parsing functionality using the `elf` crate.
+//!
+//! This may be extended in the future to support loading programs, however we
+//! currently use this for getting the sizes of sections in our kernel ELF at
+//! runtime.
+//!
+//! This is used for implementing stacktraces in std::unwind.
+//!
+//! # TODO
+//!
+//! * Add support for loading binary programs (this should probably be written
+//!   in a different module)
+
+use alloc::{format, vec::Vec};
+use elf::{
+    ElfBytes, ParseError,
+    endian::LittleEndian,
+    parse::{ParseAt, ParsingTable},
+    section::{SectionHeader, SectionHeaderTable},
+    string_table::StringTable,
+    symbol::{Symbol, SymbolTable},
+};
+use limine::request::KernelFileRequest;
+
+use crate::prelude::*;
+
+#[cfg(target_arch = "x86_64")]
+/// The length of the ELF header in bytes.
+pub const ELF_HEADER_LEN: usize = 64;
+
+/// Information about our own ELF file to make ELF parsing easier, such as the
+/// length of the file and a pointer to the contents.
+#[used]
+pub static KERNEL_FILE_REQUEST: KernelFileRequest = KernelFileRequest::new();
+
+/// A list of errors that may occur when parsing ELF files.
+#[derive(Debug)]
+pub enum ElfError {
+    /// Returned if a section did not exist in [ElfReader::get_section_size].
+    SectionNotExists,
+    /// Returned if we failed to fetch the symbol table.
+    Symtab,
+    /// Parse errors returned by the `elf` crate.
+    OtherParseError(elf::ParseError),
+}
+
+impl From<elf::ParseError> for ElfError {
+    fn from(err: elf::ParseError) -> Self {
+        Self::OtherParseError(err)
+    }
+}
+
+pub struct ElfReader {
+    /// The underlying bytes for the ELF file.
+    pub bytes: &'static [u8],
+    /// Structure returned by the `elf` crate having parsed the ELF header.
+    pub elf: ElfBytes<'static, LittleEndian>,
+    /// A sorted list of symbols to binary search.
+    pub sorted_syms: Vec<Symbol>,
+    /// The string table for looking up symbol names.
+    pub symbol_strtab: StringTable<'static>,
+}
+
+impl ElfReader {
+    /// Parses the ELF file for the kernel, this uses data from Limine's Kernel
+    /// File Request to get a slice over the whole executable file.
+    ///
+    /// # Safety
+    ///
+    /// Assumes a properly formed ELF file, and that Limine returns a correct
+    /// pointer to the start of the file as well as a valid length in bytes.
+    ///
+    /// Both of these should be satisfied, but this function is marked unsafe
+    /// just in case, because we are derefererencing arbitrary pointers.
+    pub unsafe fn new() -> Result<Self, ElfError> {
+        // Store this for use with other libraries.
+        let bytes = get_elf_slice();
+
+        let elf: ElfBytes<'static, LittleEndian> =
+            elf::ElfBytes::minimal_parse(bytes)?;
+
+        let Some((symtab, strtab)) = elf.symbol_table()? else {
+            return Err(ElfError::Symtab);
+        };
+
+        // Sort the symtab for later use and store the strtab.
+        let mut symbols = symtab.into_iter().collect::<Vec<Symbol>>();
+        symbols.sort_by_key(|sym| sym.st_value);
+
+        Ok(Self {
+            elf,
+            sorted_syms: symbols,
+            symbol_strtab: strtab,
+            bytes,
+        })
+    }
+
+    pub fn get_symbol_table(
+        &self,
+    ) -> Result<
+        Option<(SymbolTable<'static, LittleEndian>, StringTable<'static>)>,
+        ElfError,
+    > {
+        Ok(self.elf.symbol_table()?)
+    }
+
+    /// Gets the section size of `section_name` in bytes.
+    pub fn get_section_size(
+        &self,
+        section_name: &'static str,
+    ) -> Result<u64, ElfError> {
+        Ok(self.get_section_header(section_name)?.sh_size)
+    }
+
+    /// Gets the start address of the section `section_name` in memory.
+    pub fn get_section_addr(
+        &self,
+        section_name: &'static str,
+    ) -> Result<*const u8, ElfError> {
+        Ok(self.get_section_header(section_name)?.sh_addr as *const u8)
+    }
+
+    /// Gets the section header of `section_name`.
+    pub fn get_section_header(
+        &self,
+        section_name: &str,
+    ) -> Result<SectionHeader, ElfError> {
+        let section_hdr = self
+            .elf
+            .section_header_by_name(section_name)
+            .map_err(|_e| ElfError::SectionNotExists)?;
+
+        section_hdr.ok_or(ElfError::SectionNotExists)
+    }
+
+    pub fn search_symbol(&self, address: u64) -> Option<elf::symbol::Symbol> {
+        let entries = self.sorted_syms.iter().collect::<Vec<_>>();
+
+        let idx = entries
+            .as_slice()
+            .binary_search_by_key(&address, |sym| sym.st_value)
+            .ok()?;
+
+        Some(entries[idx].clone())
+    }
+
+    pub fn get_symbol_name(
+        &self,
+        sym: elf::symbol::Symbol,
+    ) -> Option<&'static str> {
+        self.symbol_strtab.get(sym.st_name as usize).ok()
+    }
+}
+
+/// Gets a slice of the bytes of the kernel ELF file.
+pub fn get_elf_slice() -> &'static [u8] {
+    let response = KERNEL_FILE_REQUEST
+        .get_response()
+        .expect("Didn't get the kernel file from Limine. That's odd.");
+
+    // We fetch these from Limine and use them to parse our own ELF file.
+    let file = response.file();
+    let file_start_ptr = file.addr();
+    let file_size = file.size() as usize;
+
+    // Safety: This slice should contain the whole bytes of the ELF file.
+    (unsafe { core::slice::from_raw_parts(file_start_ptr, file_size) }) as _
+}

kernel/src/std/io.rs

@@ -1,83 +0,0 @@
-pub use crate::arch::x86_64::drivers::{
-    ascii::{_print, _print_err, _print_log},
-    serial::_serial_write,
-};
-
-pub mod stdin {
-    use crate::arch::x86_64::drivers::{
-        ascii::WRITER,
-        keyboard::{
-            get_keystroke_async, get_keystroke_optional, KeyStroke,
-        }
-    };
-    use alloc::string::String;
-
-    /// Reads a line of input from standard input asynchronously, returning a `String` containing
-    /// the input line. Does not include the newline character at the end of the line.
-    ///
-    /// If the user presses the abort key (usually Ctrl+C), the returned string will be empty.
-    ///
-    /// This function is currently unimplemented.
-    pub async fn read_line() -> String {
-        let mut writer = WRITER.lock();
-
-        let mut buff = String::new();
-        loop {
-            match get_keystroke_async().await {
-                KeyStroke::Char(c) => match c {
-                    '\n' => {
-                        writer.write_glyph(c as u8);
-                        return buff;
-                    }
-                    '\r' => {
-                        writer.write_glyph(c as u8);
-                        return buff;
-                    }
-                    '\x08' => {
-                        if !buff.is_empty() {
-                            buff.pop();
-                            writer.backspace();
-                        }
-                    }
-
-                    c => {
-                        writer.write_glyph(c as u8);
-                        buff.push(c)
-                    }
-                },
-                KeyStroke::Enter => {
-                    writer.write_glyph(b'\n');
-                    return buff;
-                }
-                KeyStroke::Backspace => {
-                    if !buff.is_empty() {
-                        buff.pop();
-                        writer.backspace();
-                    }
-                }
-                _ => continue,
-            }
-        }
-    }
-
-    /// Reads a character from standard input and blocks the current task until a character is
-    /// available.
-    ///
-    /// # Note
-    ///
-    /// This function is not yet implemented.
-    pub async fn async_keystroke() -> KeyStroke {
-        get_keystroke_async().await
-    }
-
-    /// Attempt to read a character from standard input without blocking the current task.
-    ///
-    /// If no character is available, returns `None`.
-    ///
-    /// # Note
-    ///
-    /// This function is not yet implemented.
-    pub fn keystroke() -> Option<KeyStroke> {
-        get_keystroke_optional()
-    }
-}

kernel/src/std/io/mod.rs

@@ -0,0 +1,6 @@
+pub use crate::arch::x86_64::drivers::{
+    ascii::{_print, _print_err, _print_log},
+    serial::_serial_write,
+};
+
+pub mod stdin;

kernel/src/std/io/stdin.rs

@@ -0,0 +1,75 @@
+use crate::arch::x86_64::drivers::{
+    ascii::WRITER,
+    keyboard::{KeyStroke, get_keystroke_async, get_keystroke_optional},
+};
+use alloc::string::String;
+
+/// Reads a line of input from standard input asynchronously, returning a
+/// `String` containing the input line. Does not include the newline
+/// character at the end of the line.
+///
+/// If the user presses the abort key (usually Ctrl+C), the returned string
+/// will be empty.
+pub async fn read_line() -> String {
+    let mut writer = WRITER.lock();
+
+    let mut buff = String::new();
+    loop {
+        match get_keystroke_async().await {
+            KeyStroke::Char(c) => match c {
+                '\n' => {
+                    writer.write_glyph(c as u8);
+                    return buff;
+                }
+                '\r' => {
+                    writer.write_glyph(c as u8);
+                    return buff;
+                }
+                '\x08' => {
+                    if !buff.is_empty() {
+                        buff.pop();
+                        writer.backspace();
+                    }
+                }
+
+                c => {
+                    writer.write_glyph(c as u8);
+                    buff.push(c)
+                }
+            },
+            KeyStroke::Enter => {
+                writer.write_glyph(b'\n');
+                return buff;
+            }
+            KeyStroke::Backspace => {
+                if !buff.is_empty() {
+                    buff.pop();
+                    writer.backspace();
+                }
+            }
+            _ => continue,
+        }
+    }
+}
+
+/// Reads a character from standard input and blocks the current task until
+/// a character is available.
+///
+/// # Note
+///
+/// This function is not yet implemented.
+pub async fn async_keystroke() -> KeyStroke {
+    get_keystroke_async().await
+}
+
+/// Attempt to read a character from standard input without blocking the
+/// current task.
+///
+/// If no character is available, returns `None`.
+///
+/// # Note
+///
+/// This function is not yet implemented.
+pub fn keystroke() -> Option<KeyStroke> {
+    get_keystroke_optional()
+}

kernel/src/std/maths/geometry.rs

@@ -42,6 +42,14 @@ impl<T: Coordinate> Vec2<T> {
     pub const fn y(&self) -> T {
         self.y
     }
+
+    pub const fn set_x(&mut self, x: T) {
+        self.x = x;
+    }
+
+    pub const fn set_y(&mut self, y: T) {
+        self.y = y;
+    }
 }
 
 impl<T: Coordinate> AddAssign for Vec2<T> {

kernel/src/std/mod.rs

@@ -1,4 +1,5 @@
 pub mod application;
 pub mod ascii;
+pub mod debug;
 pub mod io;
 pub mod maths;

kernel/src/step.rs

@@ -0,0 +1,104 @@
+/* //! Defines the [Step] struct which may be used when initialising the system.
+//!
+//! # Warning
+//!
+//! Use of alloc is currently required, so early initialisation will need a
+//! different method. We should possibly abstract some functionality so that
+//! consumers don't need to worry or care about the difference.
+use alloc::{borrow::ToOwned, boxed::Box, string::String, vec::Vec};
+
+use crate::{arch::x86_64::drivers::ascii::WRITER, prelude::*};
+
+/// Represents a [Step] when initialising the system.
+///
+/// Handles printing various information to the framebuffer using steps.
+///
+/// # Example
+///
+/// ```rs
+/// // Setup a Step for Foo.
+/// let foo_step: Step<Foo, FooError> = Step::new("foo", Foo::init()).register_tag(|foo| { foo.bar().to_string() });
+/// // This returns a Result<T, E>
+/// let foo = foo_step.run()?;
+/// ```
+///
+/// # TODOs
+///
+/// * If T = Option<T> and None is returned, we print `"[Not found]"`, otherwise
+///   `"[Success]`".
+pub struct Step<T: Clone + ToOwned> {
+    /// The initialisation function for the Step, usually this is a closure.
+    init_fn: fn() -> T,
+    /// A list of tag generator functions to display under the Step on success.
+    /// They are displayed like:
+    /// ```
+    ///     Initialising module... [Success]
+    ///         => Some information here.
+    /// ```
+    ///
+    /// # TODOs
+    ///
+    /// * Support tags without alloc being initialised.
+    tags: Vec<Box<dyn Fn(T) -> String>>,
+    /// The name of the module being initialised.
+    task: &'static str,
+}
+
+// This impl block might be so horrible it needs its own file.
+impl<T: ToOwned + Clone> Step<T> {
+    pub fn new(
+        task: &'static str,
+        init_fn: fn() -> T,
+        tags: Vec<Box<dyn Fn(T) -> String>>,
+    ) -> Self {
+        Self {
+            init_fn,
+            tags,
+            task,
+        }
+    }
+
+    /// Runs the initialisation function and logs where required.
+    ///
+    /// This function is a little messy but it just handles pretty printing the
+    /// [Step] to the terminal for us.
+    pub fn run(self) -> T {
+        print_log!("    {}", self.task);
+        let mut success_position = WRITER.lock().pos();
+        success_position.set_x(success_position.x() + 1);
+
+        let ret = (self.init_fn)();
+
+        println!();
+
+        for tag in &self.tags[..] {
+            // Calls the closure on the return value.
+            println_log!("      => {}", (tag)(ret.clone()));
+        }
+
+        // Print whether or not the step succeeded.
+        print_oneshot!(
+            success_position,
+            Colour::Green,
+            Colour::Black,
+            "[Success]"
+        );
+
+        ret
+    }
+
+    /// Registers a 'tag' or note to display under the line which says
+    /// `Initialising module... [Success]`.
+    ///
+    /// # Notes
+    ///
+    /// The tag is a closure taking in a reference to T and returning a
+    /// presumably formatted String.
+    #[allow(unused)]
+    pub fn register_tag(&mut self, tag: Box<dyn Fn(T) -> String>) -> &Self {
+        self.tags.push(tag);
+
+        self
+    }
+}
+ */

kernel/src/util/editor.rs

@@ -1,15 +1,14 @@
-use crate::serial_print;
 use crate::arch::x86_64::drivers::keyboard::{KeyStroke, get_keystroke_async};
 use crate::resources::font::Font;
-use crate::std::application::frame::Frame;
-use crate::std::application::render::RenderError;
-use crate::std::application::window::Window;
-use crate::std::application::{Application, Error};
+use crate::serial_print;
+use crate::serial_println;
+use crate::std::application::{
+    Application, Error, frame::Frame, render::RenderError, window::Window,
+};
 use crate::std::ascii::Writer;
 use crate::std::maths::geometry::Vec2;
 use alloc::string::{String, ToString};
 use alloc::vec::Vec;
-use crate::serial_println;
 
 pub struct Editor {
     cursor_line: usize,
@@ -42,7 +41,8 @@ impl<'a> Editor {
 
     fn render(&'a self) -> Result<Frame<'a>, RenderError> {
         let mut frame = Frame::new(&self.window);
-        let writer = Writer::new(Font::default());
+        let font = Font::default();
+        let writer = Writer::new(&font);
 
         let (width, height) = writer.font_size().into();
 
@@ -65,7 +65,10 @@ impl<'a> Editor {
 
             writer.render_glyph(
                 &mut frame,
-                Vec2::new(col * width + Self::PADDING, line * height + Self::PADDING),
+                Vec2::new(
+                    col * width + Self::PADDING,
+                    line * height + Self::PADDING,
+                ),
                 ch as u8,
                 scale,
             )?;
@@ -124,7 +127,8 @@ impl<'a> Editor {
 
     fn get_char_idx(&self) -> usize {
         let frame = Frame::new(&self.window);
-        let writer = Writer::new(Font::default());
+        let font = Font::default();
+        let writer = Writer::new(&font);
         let (width, _height) = writer.font_size().into();
 
         let mut col = 0;
@@ -157,7 +161,10 @@ impl<'a> Editor {
 
 impl Application for Editor {
     type Output = ();
-    async fn run(&mut self, _args: Vec<alloc::string::String>) -> Result<Self::Output, Error> {
+    async fn run(
+        &mut self,
+        _args: Vec<alloc::string::String>,
+    ) -> Result<Self::Output, Error> {
         self.window.set_dimensions(Vec2::new(1280, 800));
         self.window.set_position(Vec2::new(0, 0));
         self.window.open();
@@ -167,7 +174,9 @@ impl Application for Editor {
         loop {
             if let Err(_err) = self.render().and_then(|frame| frame.render()) {
                 // TODO: Handle error
-                return Err(Error::ApplicationFailed("Rendering failed".to_string()));
+                return Err(Error::ApplicationFailed(
+                    "Rendering failed".to_string(),
+                ));
             }
 
             let keystroke = get_keystroke_async().await;

libm/src/lib.rs

@@ -1,3 +1,4 @@
+#![allow(dead_code)]
 #![feature(proc_macro_span)]
 #![warn(
     clippy::correctness,
@@ -10,9 +11,6 @@
     rustdoc::missing_panics_doc
 )]
 
-use std::fs::File;
-use std::io::{Read, Seek, SeekFrom};
-
 use proc_macro::{Span, TokenStream};
 use quote::quote;
 use std::path::PathBuf;
@@ -36,17 +34,18 @@ pub fn include_font(item: TokenStream) -> TokenStream {
     let source_filepath: PathBuf = source_file.path();
     let file_path = format!(
         "{}/{}",
-        source_filepath.parent().unwrap_or_else(|| panic!("Expected to find the calling source file in a folder like src! Got: {}", source_filepath.display())).display(),
+        source_filepath.parent()
+            .unwrap_or_else(|| panic!("Expected to find the calling source file in a folder like src! Got: {}", source_filepath.display())).display(),
         filename.value()
     );
 
-    let font_bytes = match load_file(file_path) {
+    let font_bytes = match std::fs::read(file_path) {
         Ok(bytes) => bytes,
         Err(why) => panic!("{}", why),
     };
 
-    let font_data = match Font::new(font_bytes) {
-        Ok(font) => font.0,
+    let font_data = match FontBuilder::load(font_bytes) {
+        Ok(font) => font.data,
         Err(why) => panic!("{}", why),
     };
 
@@ -62,18 +61,48 @@ pub fn include_font(item: TokenStream) -> TokenStream {
 
 struct Font([[u8; 16]; 512]);
 
-impl Font {
-    const MAGIC: u16 = 0x3604;
+struct FontData {
+    width: u8,
+    height: u8,
+    length: u16,
+    pub data: [[u8; 16]; 512],
+}
+enum FontBuilder {
+    Psf1(FontData),
+    Psf2(FontData),
+}
 
-    pub fn new(data: [u8; (32 + 2) * 512 + 4]) -> Result<Self, &'static str> {
-        let magic: u16 = (data[0] as u16) << 8 | data[1] as u16;
+impl FontBuilder {
+    const PSF1_MAGIC: u16 = 0x3604;
+    const PSF2_MAGIC: u32 = 0x72b54a86;
+
+    fn revision(data: &[u8]) -> u8 {
+        if (data[0] as u16) << 8 | data[1] as u16 == Self::PSF1_MAGIC {
+            1
+        } else if (data[0] as u32) << 24
+            | (data[1] as u32) << 16
+            | (data[2] as u32) << 8
+            | data[3] as u32
+            == Self::PSF2_MAGIC
+        {
+            2
+        } else {
+            0
+        }
+    }
+
+    pub fn load(data: Vec<u8>) -> Result<FontData, &'static str> {
+        match Self::revision(&data[0..4]) {
+            1 => Self::parse_psf1(&data),
+            2 => Self::parse_psf2(&data),
+            _ => panic!("invalid font revision result"),
+        }
+    }
+
+    fn parse_psf1(data: &[u8]) -> Result<FontData, &'static str> {
         let mode = data[2];
         let size = data[3];
 
-        if magic != Self::MAGIC {
-            return Err("Magic value is invalid!");
-        }
-
         let has_512_glyphs = (mode & 0x01) != 0;
         let mut glyphs = [[0; 16]; 512];
         let glyph_count = if has_512_glyphs { 512 } else { 256 };
@@ -86,29 +115,15 @@ impl Font {
             glyphs[i] = buff;
         }
 
-        Ok(Self(glyphs))
-    }
-}
-
-type FileContents = [u8; (32 + 2) * 512 + 4];
-fn load_file(filename: String) -> Result<FileContents, std::io::Error> {
-    let mut buf = [0; (32 + 2) * 512 + 4];
-    let mut f = File::open(filename).unwrap();
-    f.seek(SeekFrom::Start(0)).unwrap();
-
-    loop {
-        match f.read(&mut buf) {
-            Ok(read) => {
-                if read == 0 {
-                    break;
-                }
-            }
-            Err(why) => {
-                eprintln!("Failed to read PS1 font file: {}", why);
-                return Err(why);
-            }
-        }
+        Ok(FontData {
+            width: 8,
+            height: size,
+            length: glyph_count,
+            data: glyphs,
+        })
     }
 
-    Ok(buf)
+    const fn parse_psf2(_data: &[u8]) -> Result<FontData, &'static str> {
+        Err("PSF2 support is not implemented yet!")
+    }
 }

rustfmt.toml

@@ -0,0 +1,5 @@
+wrap_comments = true
+max_width = 80
+comment_width = 80
+format_code_in_doc_comments = true
+doc_comment_code_block_width = 80

scripts/run_debug.sh

@@ -32,7 +32,7 @@ else
 fi
 
 # Set up test-specific flags
-if [ $is_test -eq 1 ]; then
+if [$is_test]; then
     test_flags="-device isa-debug-exit,iobase=0xf4,iosize=0x04 -display none"
     serial_flags="-serial stdio"
 else
@@ -94,6 +94,15 @@ check_test_res() {
 
 trap 'check_test_res "tests completed"' ERR
  
+
+# NOTE(ali): For some reason the values in `boot_flags` were causing issues
+# 	     on WSL, so they've been eradicated.
+systemInfo=$(uname -r)
+if [[ $systemInfo == *"WSL"* ]]; then
+    echo "Running on WSL2"
+    boot_flags=""
+fi
+
 cd "$project_root"
 qemu-system-x86_64 -M q35 \
     -cdrom "$build_dir/image.iso" \