run_debug.sh now checks if it running on wsl and disables boot_flags if it is since it was causing issues with qemu

- apic code still not working (commented out, check lib.rs)

.cargo/config.toml

@@ -1,5 +1,5 @@
 [build]
-target = "x86_64-kernel"
+target = "x86_64-kernel.json"
 target-dir = "build/target"
 
 [unstable]

.idea/FoundryOS.iml

@@ -4,6 +4,8 @@
     <content url="file://$MODULE_DIR$">
       <sourceFolder url="file://$MODULE_DIR$/kernel/src" isTestSource="false" />
       <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" />
       <excludeFolder url="file://$MODULE_DIR$/target" />
     </content>
     <orderEntry type="inheritedJdk" />

.vscode/settings.json

@@ -1,6 +1,6 @@
 {
     "rust-analyzer.cargo.allTargets": false,
-    "rust-analyzer.cargo.target": "x86_64-kernel",
+    "rust-analyzer.cargo.target": "x86_64-kernel.json",
     "[rust]": {
         "editor.defaultFormatter": "rust-lang.rust-analyzer",
         "editor.formatOnSave": true

docs/.obsidian/appearance.json

@@ -1 +1,3 @@
-{}
+{
+  "cssTheme": "Dark Moss"
+}

docs/.obsidian/community-plugins.json

@@ -0,0 +1 @@
+[]

docs/.obsidian/plugins/obsidian-excalidraw-plugin/manifest.json

@@ -0,0 +1,12 @@
+{
+  "id": "obsidian-excalidraw-plugin",
+  "name": "Excalidraw",
+  "version": "2.8.3",
+  "minAppVersion": "1.1.6",
+  "description": "An Obsidian plugin to edit and view Excalidraw drawings",
+  "author": "Zsolt Viczian",
+  "authorUrl": "https://www.zsolt.blog",
+  "fundingUrl": "https://ko-fi.com/zsolt",
+  "helpUrl": "https://github.com/zsviczian/obsidian-excalidraw-plugin#readme",
+  "isDesktopOnly": false
+}

docs/.obsidian/workspace.json

@@ -4,41 +4,21 @@
     "type": "split",
     "children": [
       {
-        "id": "a20540b7c1ddbfca",
+        "id": "c178a2dff57ae0aa",
         "type": "tabs",
         "children": [
           {
-            "id": "e1fb15cab546d0b6",
+            "id": "6d395e6a4c72e1c8",
             "type": "leaf",
             "state": {
               "type": "markdown",
               "state": {
-                "file": "Usage/Building The Kernel.md",
+                "file": "Planning & To-Dos.md",
                 "mode": "source",
                 "source": false
               },
               "icon": "lucide-file",
-              "title": "Building The Kernel"
+              "title": "Planning & To-Dos"
-            }
-          }
-        ]
-      },
-      {
-        "id": "6bf1f87bf81a3031",
-        "type": "tabs",
-        "children": [
-          {
-            "id": "add883d295e04659",
-            "type": "leaf",
-            "state": {
-              "type": "markdown",
-              "state": {
-                "file": "Usage/Building The Kernel.md",
-                "mode": "preview",
-                "source": false
-              },
-              "icon": "lucide-file",
-              "title": "Building The Kernel"
             }
           }
         ]
@@ -73,7 +53,7 @@
             "state": {
               "type": "search",
               "state": {
-                "query": "tag:#usage",
+                "query": "",
                 "matchingCase": false,
                 "explainSearch": false,
                 "collapseAll": false,
@@ -98,8 +78,7 @@
       }
     ],
     "direction": "horizontal",
-    "width": 200,
+    "width": 307.5
-    "collapsed": true
   },
   "right": {
     "id": "baa2a8e61b737fa6",
@@ -177,7 +156,8 @@
       }
     ],
     "direction": "horizontal",
-    "width": 300
+    "width": 300,
+    "collapsed": true
   },
   "left-ribbon": {
     "hiddenItems": {
@@ -185,14 +165,21 @@
       "graph:Open graph view": false,
       "canvas:Create new canvas": false,
       "daily-notes:Open today's daily note": false,
-      "templates:Insert template": false,
+      "command-palette:Open command palette": false,
-      "command-palette:Open command palette": false
+      "templates:Insert template": false
     }
   },
-  "active": "add883d295e04659",
+  "active": "6d395e6a4c72e1c8",
   "lastOpenFiles": [
+    "Usage/Building The Kernel.md",
+    "Planning & To-Dos.md",
+    "structure/idk.canvas",
+    "structure/kernel.md",
+    "structure/libk.md",
+    "structure/libm.md",
+    "structure/libk",
+    "structure",
     "Usage",
-    "Welcome.md",
+    "Welcome.md"
-    "Usage/Building The Kernel.md"
   ]
 }

docs/Planning & To-Dos.md

@@ -0,0 +1,130 @@
+> [!todo] Testing
+> - [ ] setup custom test frameworks (Use CrystalOS-V2 as a reference)
+> 	- [ ] write a sub-crate for tests
+> 	- [ ] implement several unit tests on things that we are likely to break often
+> - [ ] setup Git CI/CD pipeline with testing
+> 	- [ ] figure out how to run QEMU in the test environment
+> 	- [ ] write a script to run tests
+> 	- [ ] a release should only be published if all tests pass
+
+> [!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
+> - [ ] testing
+> 	- [ ] write unit tests
+> 		- [ ] many allocations
+> 		- [ ] large allocations
+> 		- [ ] allocating more memory than is available
+> 	- [ ] pass unit tests
+
+> [!todo] Threading
+> - [ ] implement thread switching functionality
+> 	- [ ] switch stacks
+> - [ ] implement multi-threading
+> 	- [ ] figure out how to turn on another core
+> - [ ] Scheduler
+> 	- [ ] which task goes on which thread?
+> 		- [ ] round robin / time slicing algorithm
+> 	- [ ] switch tasks on a given core
+> 		- [ ] push registers
+> 		- [ ] switch stacks
+> 		- [ ] ensure the scheduler knows where to find the stack for each thread
+> 	- [ ] move a given task to a new core
+> 	- [ ] differentiate between kernel threads and user threads
+> - [ ] create syscall to create a new thread
+
+> [!todo] Filesystem 
+> - [ ] AHCI Implementation
+> 	- [ ] figure out what hard drives are attached
+> 	- [ ] read data
+> 	- [ ] write data
+> - [ ] FAT32 Implementation
+> 	- [ ] parse FAT header
+> 	- [ ] figure out where files are / what files are what
+> 	- [ ] parse file metadata / figure out type of file
+> 	- [ ] reading the entirety of a file into memory
+> - [ ] *(extension)* ext2 Implementation
+> - [ ] Syscall API
+> 	- [ ] provide a user program with file read / write access given a filename
+> 		- [ ] translate a filename into a disk location of data & the size of the data
+> 		- [ ] provide an interface to read from a file or write to a file
+
+> [!todo] APIC
+> - [ ] Enable APIC
+> 	- [x] Get apic location  from MSR
+> 	- [x] Enable APIC bit flag
+> 	- [x] Disable Legacy PIC
+> 	- [ ] Map physical APIC address to virtual memory
+> 
+>> [!error]
+>> Page fault exception occurs when APIC is activated
+>
+>- [ ] Setup Interrupt handlers to handle interrupts generated by the APIC
+>	- [ ] Timer Interrupts
+>	- [ ] Keyboard Interrupts
+
+> [!todo] Userspace (req: Threading, Filesystem)
+> - [ ] Load program into memory from disk
+> 	- [ ] requires:
+> 		- [ ] Program Loader
+> 			- [ ] Parse ELF File
+> 			- [ ] Load file into memory
+> 		- [ ] Filesystem
+> 		- [ ] Scheduler (to start and manage the process)
+> - [ ] Start a user process
+> 	- [ ] switch stacks
+> 	- [ ] jump to user code
+
+>[!todo] User Interface 
+>- This will be a library so that  programs in userspace can provide a user interface rather than relying on text commands from a basic terminal
+>- features required:
+>	- [ ] Rendering frames to a display buffer
+>		- [ ] requires: Frame rendering Syscall
+>	- [ ] I/O
+>		- [ ] syncio
+>			- [ ] keystrokes
+>		- [ ] asyncio
+>			- [ ] keystrokes
+>		- [ ] requires: I/O Syscalls
+>	- [ ] Window struct
+>		- [ ] stores it's size and location
+>		- [ ] handles rendering pixels to the screen
+>	- [ ] Widgets
+>		- [ ] textbox / label
+>		- [ ] single line text input
+>			- [ ] how do we capture keyboard inputs?
+>		- [ ] multiline text input
+>			- [ ] how do we capture keyboard inputs?
+>		- [ ] button
+>		- [ ] dialog
+>		- [ ] box widget
+>			- [ ] figure out how to nest other widgets inside it
+>```rust
+>pub struct Window {
+>	position;
+>	dimensions;
+>}
+>
+>impl Window {
+>	fn display(&self, frame: &Frame) -> Result<(), RenderError>;
+>}
+>
+>pub struct Frame<'a> {
+>	window: &'a Window,
+>	data: <"... a suitable type to store pixels">
+>}
+>
+>impl<'a> Frame<'a> {
+>	pub fn display(&self) -> Result<(), RenderError> {
+>		self.window.display(self)
+>	}
+>}
+>
+> pub trait Widget {
+> 	fn render(&self) -> Frame;
+> }
+>```
+

docs/structure/idk.canvas

@@ -0,0 +1,41 @@
+{
+	"nodes":[
+		{"id":"8391ed519ab6cb3d","type":"group","x":-920,"y":600,"width":1595,"height":360,"label":"Hardware Layer"},
+		{"id":"967decfbdbf166e2","type":"group","x":-920,"y":120,"width":1595,"height":320,"label":"Kernel Layer (kernelspace)"},
+		{"id":"efd3cf75db396678","type":"group","x":-920,"y":-280,"width":1595,"height":240,"label":"System Layer (userspace)"},
+		{"id":"d577e6c4fa3d7479","type":"group","x":-920,"y":-600,"width":1595,"height":140,"label":"User Layer (userspace)"},
+		{"id":"549099b4188ff073","type":"text","text":"Interrupt handling & initialisation","x":-204,"y":320,"width":250,"height":60,"color":"2"},
+		{"id":"d0c73e9e86edba62","type":"text","text":"Kernel #kernel","x":-220,"y":260,"width":281,"height":140,"color":"2"},
+		{"id":"4fdc8ae730503ad0","type":"text","text":"libk #kernel","x":-880,"y":260,"width":280,"height":140,"color":"2"},
+		{"id":"4839a4f4f0980254","type":"text","text":"System Libraries #userspace","x":-220,"y":-240,"width":281,"height":160,"color":"3"},
+		{"id":"ba48ee2ccc891a62","type":"text","text":"Scheduler","x":-880,"y":160,"width":280,"height":60,"color":"2"},
+		{"id":"3d31fc276e0ba4a0","type":"text","text":"UI Shell #userspace","x":-880,"y":-560,"width":280,"height":60,"color":"4"},
+		{"id":"6b5e17c10589a7b6","type":"text","text":"Generic Application #userspace","x":-219,"y":-560,"width":281,"height":60,"color":"4"},
+		{"id":"0a47f47a2c7b3609","type":"text","text":"CPU #hardware","x":-880,"y":640,"width":280,"height":280,"color":"1"},
+		{"id":"a7002e4427f0540d","type":"text","text":"lib_io","x":-200,"y":-160,"width":122,"height":60,"color":"3"},
+		{"id":"e09d0bccffd19ed9","type":"text","text":"lib_ui","x":-78,"y":-160,"width":118,"height":60,"color":"3"},
+		{"id":"cbfeda8989b260d8","type":"text","text":"Userspace Drivers #userspace","x":360,"y":-240,"width":281,"height":160,"color":"3"},
+		{"id":"3acced35498279a0","type":"text","text":"Hardware #hardware\n- Display\n- Hard drives\n- Keyboard\n- Mouse","x":360,"y":640,"width":281,"height":280,"color":"1"},
+		{"id":"31548bb91b4977eb","type":"text","text":"Syscall API","x":-219,"y":160,"width":281,"height":60,"color":"2"},
+		{"id":"110b7bee2ba99819","type":"text","text":"Drivers & low level kernel libraries","x":-860,"y":320,"width":240,"height":60,"color":"2"}
+	],
+	"edges":[
+		{"id":"6a8d6b7540c2898d","fromNode":"3d31fc276e0ba4a0","fromSide":"right","toNode":"4839a4f4f0980254","toSide":"left","color":"3"},
+		{"id":"57aedf427a150ff1","fromNode":"6b5e17c10589a7b6","fromSide":"bottom","toNode":"4839a4f4f0980254","toSide":"top","color":"3","label":"Applications are statically \nlinked to system libraries"},
+		{"id":"d292a19f88032809","fromNode":"4839a4f4f0980254","fromSide":"bottom","toNode":"31548bb91b4977eb","toSide":"top","color":"2","label":"system libraries make syscalls"},
+		{"id":"8b437f1c08e1caf2","fromNode":"ba48ee2ccc891a62","fromSide":"top","toNode":"3d31fc276e0ba4a0","toSide":"bottom","color":"4","label":"Scheduler Starts\nUI in userspace"},
+		{"id":"3e2c6f6d5dcd7613","fromNode":"4839a4f4f0980254","fromSide":"right","toNode":"cbfeda8989b260d8","toSide":"left","color":"3"},
+		{"id":"88f6e95c288c933d","fromNode":"31548bb91b4977eb","fromSide":"top","toNode":"4839a4f4f0980254","toSide":"bottom","color":"2"},
+		{"id":"156c8a89b537e219","fromNode":"cbfeda8989b260d8","fromSide":"left","toNode":"4839a4f4f0980254","toSide":"right","color":"3","label":"some libs talk to\nhardware through\nuserspace drivers"},
+		{"id":"0d04c5b0f76a5d9b","fromNode":"cbfeda8989b260d8","fromSide":"bottom","toNode":"3acced35498279a0","toSide":"top","fromEnd":"arrow","color":"1","label":"Userspace drivers can talk\ndirectly to hardware so\nin the case of a driver crash\nthe kernel is unaffected"},
+		{"id":"e9f1afb45bf17b77","fromNode":"4fdc8ae730503ad0","fromSide":"bottom","toNode":"3acced35498279a0","toSide":"left","fromEnd":"arrow","color":"1","label":"Libk handles most hardware\ninteraction, keeping the core kernel codebase as minimal\nas possible"},
+		{"id":"99414d640e519c8c","fromNode":"4fdc8ae730503ad0","fromSide":"right","toNode":"d0c73e9e86edba62","toSide":"left","fromEnd":"arrow","color":"2","label":"kernel static linked to libk\nmost kernel functionality\nisfound in libk"},
+		{"id":"85cd865c914dd125","fromNode":"549099b4188ff073","fromSide":"top","toNode":"d0c73e9e86edba62","toSide":"top","color":"2"},
+		{"id":"e882694ec774c0d6","fromNode":"4fdc8ae730503ad0","fromSide":"top","toNode":"ba48ee2ccc891a62","toSide":"bottom","color":"2"},
+		{"id":"c689b667be8cdfab","fromNode":"d0c73e9e86edba62","fromSide":"top","toNode":"31548bb91b4977eb","toSide":"bottom","color":"2"},
+		{"id":"0c9da0cce11e4bd1","fromNode":"ba48ee2ccc891a62","fromSide":"bottom","toNode":"4fdc8ae730503ad0","toSide":"top","color":"2"},
+		{"id":"c45efb0ad498f8a8","fromNode":"ba48ee2ccc891a62","fromSide":"right","toNode":"6b5e17c10589a7b6","toSide":"left","color":"4","label":"Scheduler\nstarts applications"},
+		{"id":"aee2cd6ef9682f0f","fromNode":"31548bb91b4977eb","fromSide":"left","toNode":"ba48ee2ccc891a62","toSide":"right","color":"2","label":"system libs can talk to\nthe scheduler to manage\nprocesses"},
+		{"id":"b1b2b96d8ac2b490","fromNode":"4fdc8ae730503ad0","fromSide":"bottom","toNode":"0a47f47a2c7b3609","toSide":"top","fromEnd":"arrow","color":"1"}
+	]
+}

docs/structure/libm.md

@@ -0,0 +1,16 @@
+- contains all proc macros for building the kernel
+
+## Current Features 
+### font importer:
+- a macro that takes a filename to a font file and turns it into a font.
+```rust 
+pub struct Font {
+	width: usize,
+	height: usize,
+	length: u16,
+	data: [[u8; 16]; 512],
+}
+
+pub static FONT_CP850_8X16: Font = 
+	Font::new(include_font!("./libk/resources/font/cp850-8x16.psf"));
+```

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

@@ -1,14 +1,19 @@
-#![allow(unused)] // TODO: Remove this when ready.
 use core::arch::x86_64::__cpuid;
 
+use libk::drivers::memory::{FoundryOSFrameAllocator, FRAME_ALLOCATOR, OFFSET_PAGE_TABLE};
+use spin::Lazy;
 use x86_64::{
     PhysAddr, VirtAddr,
-    structures::paging::{Mapper, Size4KiB},
+    instructions::port::Port,
+    registers::model_specific::Msr,
+    structures::paging::{
+        FrameAllocator, Mapper, Page, PageTableFlags, PhysFrame, Size4KiB, Translate,
+    },
 };
 
 use crate::serial_print;
 
-use super::{cpu::model_specific_registers::*, mem::memmap::PHYSICAL_MEMORY_OFFSET};
+use super::{cpu::model_specific_registers::*, memmap::PHYSICAL_MEMORY_OFFSET};
 
 const IA32_APIC_BASE_MSR: u32 = 0x1b;
 const IA32_APIC_BASE_MSR_BSP: u64 = 0x100;
@@ -63,49 +68,37 @@ pub fn check_apic() -> bool {
 #[inline(always)]
 unsafe fn phys_to_virt(phys: PhysAddr) -> VirtAddr {
     let phys = phys.as_u64();
-    phys.checked_add(*PHYSICAL_MEMORY_OFFSET).map_or_else(
+    phys.checked_add(*PHYSICAL_MEMORY_OFFSET).map_or_else(|| panic!(" overflow"), VirtAddr::new)
-        || {
-            serial_print!("THIS IS A PROBLEM");
-            panic!("overflow")
-        },
-        |virt| {
-            serial_print!("map worked!");
-            VirtAddr::new(virt)
-        },
-    )
 }
 
-pub fn enable_apic(
+pub fn enable_apic() {
-    _mapper: &mut impl Mapper<Size4KiB>,
+    let mut mapper = OFFSET_PAGE_TABLE.get().unwrap().lock();
-    // TODO: Fix this function.
+    let mut frame_allocator = FRAME_ALLOCATOR.get().unwrap().lock();
-    // frame_allocator: &mut FoundryOSFrameAllocator,
-) {
-    unimplemented!();
 
-    // let apic_phys_addr = get_apic_base();
+    let apic_phys_addr = get_apic_base();
-    // set_apic_base_enable(apic_phys_addr);
+    set_apic_base_enable(apic_phys_addr);
     // map virt address of apic
 
-    // let apic_virt = unsafe { phys_to_virt(apic_phys_addr) };
+    let apic_virt = unsafe { phys_to_virt(apic_phys_addr) };
-    // let page: Page<Size4KiB> = Page::containing_address(apic_virt);
+    let page: Page<Size4KiB> = Page::containing_address(apic_virt);
-    // let frame: PhysFrame<Size4KiB> = PhysFrame::containing_address(apic_phys_addr);
+    let frame: PhysFrame<Size4KiB> = PhysFrame::containing_address(apic_phys_addr);
-    // let flags: PageTableFlags = PageTableFlags::PRESENT | PageTableFlags::WRITABLE;
+    let flags: PageTableFlags = PageTableFlags::PRESENT | PageTableFlags::WRITABLE;
 
-    // unsafe {
+    unsafe {
-    //     match mapper.map_to(page, frame, flags, frame_allocator) {
+        match mapper.map_to(page, frame, flags, &mut *frame_allocator) {
-    //         Ok(_) => {}
+            Ok(_) => {}
-    //         Err(why) => panic!("failed to map apic: {:?}", why),
+            Err(why) => panic!("failed to map apic: {:?}", why),
-    //     }
+        }
-    // }
+    }
 
     // // FIXME: this causes a page fault
     // // TODO: map to virtual memor
 
-    // let reg = read_apic_register(&apic_virt, 0xF0);
+    let reg = read_apic_register(&apic_virt, 0xF0);
 
-    // serial_print!("ok2");
+    serial_print!("ok2");
 
-    // write_apic_register(&apic_virt, 0xF0, reg | 0x100);
+    write_apic_register(&apic_virt, 0xF0, reg | 0x100);
 }
 
 pub struct Apic {}

kernel/src/arch/x86_64/cpu.rs

@@ -3,11 +3,11 @@ pub mod model_specific_registers {
     use spin::Lazy;
     use x86_64::registers::model_specific::Msr;
 
-    const _CPUID_FLAG_MSR: u32 = 1 << 5;
+    const CPUID_FLAG_MSR: u32 = 1 << 5;
-    static _EDX: Lazy<u32> = Lazy::new(|| unsafe { __cpuid(1).edx });
+    static EDX: Lazy<u32> = Lazy::new(|| unsafe { __cpuid(1).edx });
 
-    pub fn _cpu_has_msr() -> bool {
+    pub fn cpu_has_msr() -> bool {
-        *_EDX & _CPUID_FLAG_MSR != 0
+        *EDX & CPUID_FLAG_MSR != 0
     }
 
     pub fn cpu_get_msr(msr: u32, value: &mut u64) {

kernel/src/arch/x86_64/interrupts.rs

@@ -1,7 +1,10 @@
-// use libk::drivers::mem::{FRAME_ALLOCATOR, OFFSET_PAGE_TABLE};
+use libk::drivers::memory::{FRAME_ALLOCATOR, OFFSET_PAGE_TABLE};
 use libk::prelude::*;
 use pic8259::ChainedPics;
+use x86_64::registers::control::Cr2;
 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 spin::{Lazy, Mutex};
 
@@ -60,7 +63,6 @@ pub fn enable_pic() {
     }
 }
 
-#[expect(unused)]
 pub fn disable_pic() {
     unsafe {
         PICS.lock().disable();
@@ -89,7 +91,7 @@ extern "x86-interrupt" fn double_fault_handler(
 }
 
 extern "x86-interrupt" fn keyboard_interrupt_handler(_stack_frame: InterruptStackFrame) {
-    use pc_keyboard::{HandleControl, Keyboard, ScancodeSet1, layouts};
+    use pc_keyboard::{layouts, HandleControl, Keyboard, ScancodeSet1};
     // use pc_keyboard::DecodedKey;
     use spin::Mutex;
     use x86_64::instructions::port::Port;
@@ -125,29 +127,28 @@ extern "x86-interrupt" fn page_fault_handler(
     _stack_frame: InterruptStackFrame,
     _error_code: PageFaultErrorCode,
 ) {
-    todo!("Get this working again.")
+    serial_println!("Exception: Page Fault");
-    // serial_println!("Exception: Page Fault");
+    serial_println!("Accessed Address: {:?}", Cr2::read());
-    // serial_println!("Accessed Address: {:?}", Cr2::read());
+    serial_println!("Error Code: {:?}", _error_code);
-    // serial_println!("Error Code: {:?}", error_code);
+    serial_println!("{:#?}", _stack_frame);
-    // serial_println!("{:#?}", stack_frame);
 
-    // if let Some(frame_allocator) = FRAME_ALLOCATOR.get() {
+    if let Some(frame_allocator) = FRAME_ALLOCATOR.get() {
-    //     let mut f = frame_allocator.lock();
+        let mut f = frame_allocator.lock();
 
-    //     let frame = f.allocate_frame().unwrap();
+        let frame = f.allocate_frame().unwrap();
-    //     let flags = PageTableFlags::PRESENT | PageTableFlags::WRITABLE;
+        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 {
+        unsafe {
-    //         let mut mapper = OFFSET_PAGE_TABLE.get().unwrap().lock();
+            let mut mapper = OFFSET_PAGE_TABLE.get().unwrap().lock();
 
-    //         match mapper.map_to(page, frame, flags, &mut *f) {
+            match mapper.map_to(page, frame, flags, &mut *f) {
-    //             Ok(_) => {}
+                Ok(_) => {}
-    //             Err(why) => panic!("failed to map page: {:?}", why),
+                Err(why) => panic!("failed to map page: {:?}", why),
-    //         }
+            }
-    //     }
+        }
-    //     MapperFlushAll::new().flush_all();
+        MapperFlushAll::new().flush_all();
-    // } else {
+    } else {
-    //     panic!("failed to get frame allocator");
+        panic!("failed to get frame allocator");
-    // }
+    }
 }

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

@@ -1,2 +0,0 @@
-pub mod memmap;
-pub mod pmm;

kernel/src/arch/x86_64/mod.rs

@@ -1,5 +1,9 @@
-pub mod apic;
-pub mod cpu;
 pub mod gdt;
+
 pub mod interrupts;
-pub mod mem;
+
+pub mod memmap;
+
+pub mod apic;
+
+pub mod cpu;

kernel/src/lib.rs

@@ -13,14 +13,16 @@
 
 extern crate alloc;
 
-// use arch::x86_64::apic::enable_apic;
+use arch::x86_64::apic::enable_apic;
 use core::arch::asm;
-// use libk::drivers::mem::pmm;
+use libk::drivers::memory;
 use limine::BaseRevision;
 
-// use libk::drivers::alloc::allocator::init_heap;
+use libk::drivers::kalloc::allocator::init_heap;
 use libk::prelude::*;
 
+use x86_64::VirtAddr;
+
 mod arch;
 
 /// Sets the base revision to the latest revision supported by the crate.
@@ -56,9 +58,9 @@ pub fn boot() -> Result<(), &'static str> {
         return Err("base revision not supported");
     }
 
-    use arch::x86_64::{gdt, interrupts, mem::memmap};
+    use arch::x86_64::{gdt, interrupts, memmap};
 
-    let _memory_map = memmap::get_memory_map();
+    let memory_map = memmap::get_memory_map();
 
     print_log!("    Initialising Serial... ");
     if libk::drivers::io::serial::init().is_err() {
@@ -76,19 +78,18 @@ pub fn boot() -> Result<(), &'static str> {
     println_log!("[Success]");
 
     print_log!("    Initialising Memory Subsystem... ");
-    // let physical_memory_offset = VirtAddr::new(*memmap::PHYSICAL_MEMORY_OFFSET);
+    let physical_memory_offset = VirtAddr::new(*memmap::PHYSICAL_MEMORY_OFFSET);
-    // pmm::init_page_table(physical_memory_offset);
+    memory::init_page_table(physical_memory_offset);
     println_log!("[Success]");
 
     print_log!("    Setting Up Page Table... ");
-    // pmm::init_frame_allocator(memory_map);
+    memory::init_frame_allocator(memory_map);
     println_log!("[Success]");
 
     print_log!("    Initialising Heap... ");
-    // TODO: Reenable the heap.
+    if init_heap().is_err() {
-    // if init_heap().is_err() {
+        return Err("Failed to initialise heap: error");
-    // return Err("Failed to initialise heap: error");
+    }
-    // }
     println_log!("[Success]");
 
     print_log!("    Enabling PICs... ");
@@ -98,9 +99,9 @@ pub fn boot() -> Result<(), &'static str> {
     // print_log!("    Disabling PICs... ");
     // interrupts::disable_pic();
     // println_log!("[Success]");
-    //
+
     // print_log!("    Initialising APIC");
-    // enable_apic(&mut l4_table, &mut frame_allocator);
+    // enable_apic();
     // println_log!("[Success]");
 
     print_log!("    Enabling Interrupts... ");

kernel/src/main.rs

@@ -3,10 +3,11 @@
 
 extern crate alloc;
 
+use alloc::vec;
 use libk::{
     drivers::{
         async_io::task::{Executor, Task},
-        io,
+        io::{self, framebuffer::colour::Colour},
     },
     prelude::*,
     util::shell::shell,
@@ -27,14 +28,16 @@ extern "C" fn kmain() -> ! {
     println!("Dimensions: {}x{} (px)", dimensions2.0, dimensions2.1);
     println!("Dimensions: {}x{} (chars)", dimensions.0, dimensions.1);
 
+    // println!("TESTING :: Allocation");
+    // let somevec = vec![0; 1_000_000];
+    // println!("{:?}", somevec);
+    // println!("{}", somevec.len());
+    // println!("PASSED!");
+
+
     let mut executor = Executor::new();
-
-    let mut v = Vec::with_capacity(1000 * 1000);
-    for i in 0..1000 * 1000 {
-        v.push(i);
-    }
-    println!("v.len(): {}", v.len());
-
     executor.spawn(Task::new(shell()));
     executor.run();
+
+    loop {}
 }

libk/Cargo.toml

@@ -18,5 +18,5 @@ spin = "0.9.8"
 futures-util = { version = "0.3.31", default-features = false, features = [
     "alloc",
 ] }
-linked_list_allocator = "0.10.5"
+linked_list_allocator = { version = "0.10.5", features = ["use_spin"] }
 libm = { path = "../libm" }

libk/README.md

@@ -12,7 +12,7 @@ libk is an attempt to move away from the godforsaken git submodules that plagued
 
 A lot of things must be improved and worked on, feel free to add extra TODOs below.
 
-[] Create a kernel logging abstraction similar to Linux. (this should probably just use the serial drivers)
+- [] Create a kernel logging abstraction similar to Linux. (this should probably just use the serial drivers)
 
 The rationale behind this is that we want some sort of debug log/tracing support so we aren't just printf debugging forever.
 

libk/src/drivers/io/ascii/mod.rs

@@ -72,7 +72,7 @@ impl Writer {
         }
 
         // Get the character data from the font array. -- each byte is a row of pixels
-        let data: &[u8] = &self.font.glyphs[c as usize];
+        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) {

libk/src/drivers/io/framebuffer/display.rs

@@ -61,9 +61,16 @@ impl FramebufferWriter {
         }
     }
 
-    pub fn render_frame(&self, buffer: &[Colour; 1280 * 800]) {
+    pub fn render_frame(&self, buffer: &[&[Colour]]) {
-        for (y, row) in buffer.chunks(1280).enumerate() {
+        // TODO: this should return errors
+        for (y, &row) in buffer.iter().enumerate() {
+            if y >= self.height() as usize {
+                break;
+            }
             for (x, pixel) in row.iter().enumerate() {
+                if x >= self.width() as usize {
+                    break;
+                }
                 self.write_pixel(x, y, *pixel);
             }
         }

libk/src/drivers/kalloc/allocator.rs

@@ -0,0 +1,42 @@
+use linked_list_allocator::LockedHeap;
+use spin::{Mutex, MutexGuard};
+use x86_64::structures::paging::{
+    mapper::MapToError,
+    Size4KiB,
+};
+use crate::drivers::kalloc::foundry_kalloc::FoundryAllocator;
+
+/// 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());
+
+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.
+pub fn init_heap() -> Result<(), MapToError<Size4KiB>> {
+    // code to allocate frames is now done in the page fault interrupt handler!
+
+    unsafe {
+        ALLOCATOR.lock().init(HEAP_START, HEAP_SIZE);
+    }
+
+    Ok(())
+}
+
+pub struct Locked<T> {
+    inner: Mutex<T>,
+}
+
+impl<T> Locked<T> {
+    pub const fn new(inner: T) -> Self {
+        Locked {
+            inner: Mutex::new(inner)
+        }
+    }
+
+    pub fn lock(&self) -> MutexGuard<T> {
+        self.inner.lock()
+    }
+}

libk/src/drivers/kalloc/foundry_kalloc.rs

@@ -0,0 +1,231 @@
+use alloc::collections::LinkedList;
+use core::alloc::{GlobalAlloc, Layout};
+use core::{mem, ptr};
+use core::ptr::NonNull;
+use crate::drivers::kalloc::allocator::Locked;
+const BLOCK_SIZES: &[usize] = &[8, 16, 32, 64, 128, 256, 512, 1024, 2048];
+
+struct ListNode {
+    next: Option<&'static mut ListNode>,
+}
+
+pub struct FoundryAllocator {
+    list_heads: [Option<&'static mut ListNode>; BLOCK_SIZES.len()],
+    fallback: Locked<FoundryFallbackAllocator>,
+}
+
+impl Default for FoundryAllocator {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl FoundryAllocator {
+    pub const fn new() -> Self {
+        const EMPTY: Option<&'static mut ListNode> = None;
+        Self {
+            list_heads: [EMPTY; BLOCK_SIZES.len()],
+            fallback: Locked::new(FoundryFallbackAllocator::new()),
+        }
+    }
+    pub unsafe fn init(&mut self, heap_start: usize, heap_size: usize) { unsafe {
+        self.fallback.lock().init(heap_start, heap_size);
+    }}
+
+    unsafe fn fallback_alloc(&mut self, layout: Layout) -> *mut u8 { unsafe {
+        self.fallback.alloc(layout)
+    }}
+
+    fn block_size(&self, layout: &Layout) -> Option<usize> {
+        let required_block_size = layout.size().max(layout.align());
+        BLOCK_SIZES.iter().position(|&s| s >= required_block_size)
+    }
+}
+
+unsafe impl GlobalAlloc for Locked<FoundryAllocator> {
+    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+        let mut allocator = self.lock();
+
+        match allocator.block_size(&layout) {
+            Some(index) => {
+                match allocator.list_heads[index].take() {
+                    Some(node) => {
+                        allocator.list_heads[index] = node.next.take();
+                        node as *mut ListNode as *mut u8
+                    }
+                    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();
+                        unsafe { allocator.fallback_alloc(layout) }
+                    }
+                }
+            }
+            None => unsafe { allocator.fallback_alloc(layout) },
+        }
+    }
+
+
+    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
+        let mut allocator = self.lock();
+        match allocator.block_size(&layout) {
+            Some(idx) => {
+                let new_node = ListNode {
+                    next: allocator.list_heads[idx].take(),
+                };
+
+                let new_ptr = ptr as *mut ListNode;
+                unsafe { new_ptr.write(new_node) };
+                allocator.list_heads[idx] = Some( unsafe { &mut *new_ptr });
+            }
+            None => {;
+                unsafe { allocator.fallback.dealloc(ptr, layout) };
+            }
+        }
+    }
+}
+
+struct FallbackListNode {
+    size: usize,
+    next: Option<&'static mut FallbackListNode>,
+}
+
+impl FallbackListNode {
+    const fn new(size: usize) -> Self {
+        Self {
+            size,
+            next: None,
+        }
+    }
+
+    fn start_addr(&self) -> usize {
+        self as *const Self as usize
+    }
+
+    fn end_addr(&self) -> usize {
+        self.start_addr() + self.size
+    }
+}
+
+pub struct FoundryFallbackAllocator {
+    head: FallbackListNode,
+}
+
+impl FoundryFallbackAllocator {
+    pub const fn new() -> Self {
+        Self {
+            head: FallbackListNode::new(0),
+        }
+    }
+
+    pub unsafe fn init(&mut self, heap_start: usize, heap_size: usize) {
+        unsafe { self.add_region(heap_start, heap_size) };
+    }
+
+    unsafe fn add_region(&mut self, addr: usize, size: usize) { unsafe {
+        let mut node = FallbackListNode::new(size);
+        node.next = self.head.next.take();
+        let node_ptr = addr as *mut FallbackListNode;
+        node_ptr.write(node);
+        self.head.next = Some(&mut *node_ptr);
+    }}
+
+    fn find_region(&mut self, size: usize, align: usize) -> Option<(&'static mut FallbackListNode, usize)> {
+        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) {
+                // region suitable for allocation -> remove node from list
+                let next = region.next.take();
+                let ret = Some((current.next.take().unwrap(), alloc_start));
+                current.next = next;
+                return ret;
+            } else {
+                // region not suitable -> continue with next region
+                current = current.next.as_mut().unwrap();
+            }
+        }
+        None
+    }
+    const fn align_up(addr: usize, align: usize) -> usize {
+        (addr + align - 1) & !(align - 1)
+    }
+
+    fn size_align(layout: Layout) -> (usize, usize) {
+        let layout = layout
+            .align_to(align_of::<ListNode>())
+            .expect("adjusting alignment failed")
+            .pad_to_align();
+        let size = layout.size().max(size_of::<ListNode>());
+        (size, layout.align())
+    }
+
+    fn alloc_from_region(region: &FallbackListNode, size: usize, align: usize) -> Result<usize, ()>
+    {
+        let alloc_start = Self::align_up(region.start_addr(), align);
+        let alloc_end = alloc_start.checked_add(size).ok_or(())?;
+
+        if alloc_end > region.end_addr() {
+            return Err(());
+        }
+
+        let excess_size = region.end_addr() - alloc_end;
+        if excess_size > 0 && excess_size < size_of::<ListNode>() {
+            return Err(());
+        }
+
+        Ok(alloc_start)
+    }
+}
+
+unsafe impl GlobalAlloc for Locked<FoundryFallbackAllocator> {
+    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+        let mut allocator = self.lock();
+        // perform layout adjustments
+        let (size, align) = FoundryFallbackAllocator::size_align(layout);
+
+        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
+        } else {
+            ptr::null_mut()
+        }
+    }
+
+    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
+        let mut allocator = self.lock();
+
+        // perform layout adjustments
+        let (size, _) = FoundryFallbackAllocator::size_align(layout);
+
+        unsafe {
+            allocator.add_region(ptr as usize, size)
+        }
+    }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

libk/src/drivers/kalloc/mod.rs

@@ -0,0 +1,2 @@
+pub mod allocator;
+mod foundry_kalloc;

libk/src/drivers/memory.rs

@@ -0,0 +1,149 @@
+// use lib_alloc::allocator::FoundryAllocator;
+use limine::{memory_map::EntryType, response::MemoryMapResponse};
+use spin::{Mutex, Once};
+use x86_64::{
+    registers::control::Cr3, structures::paging::{
+        FrameAllocator, OffsetPageTable, PageTable, PhysFrame, Size4KiB
+        ,
+    },
+    PhysAddr,
+    VirtAddr,
+};
+
+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
+///
+/// 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 {
+    let (level_4_frame, _) = Cr3::read();
+
+    let phys_addr = level_4_frame.start_address();
+    let virt = phys_addr.as_u64() + physical_memory_offset.as_u64();
+    unsafe { &mut *(virt as *mut PageTable) }
+}
+
+/// Initializes the `OffsetPageTable` for the current CPU architecture.
+///
+/// # Safety
+///
+/// This function must be called only once and should be called before any
+/// memory operations are performed that rely on virtual memory management.
+/// The provided `physical_memory_offset` must be accurate to ensure correct
+/// translation of physical addresses.
+///
+/// # Parameters
+///
+/// - `physical_memory_offset`: The offset to convert physical addresses to
+///   virtual addresses in the higher-half direct map.
+///
+/// # Returns
+///
+/// Returns an `OffsetPageTable` that allows for manipulation of the page
+/// tables for the current CPU architecture.
+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);
+        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()))
+// }

libk/src/drivers/mod.rs

@@ -1,3 +1,6 @@
-pub mod async_io;
 pub mod io;
+pub mod kalloc;
+
+pub mod async_io;
+pub mod memory;
 pub mod pic;

libk/src/drivers/pic.rs

@@ -40,8 +40,8 @@ pub struct ChainedPics {
 }
 
 impl ChainedPics {
-    pub const fn new(offset1: u8, offset2: u8) -> Self {
+    pub const unsafe fn new(offset1: u8, offset2: u8) -> Self {
-        Self {
+        ChainedPics {
             pics: [
                 Pic {
                     offset: offset1,
@@ -57,14 +57,20 @@ impl ChainedPics {
         }
     }
 
-    pub const fn new_contiguous(primary_offset: u8) -> Self {
+    /// .
-        Self::new(primary_offset, primary_offset + 8)
+    ///
-    }
-
     /// # Safety
     ///
-    /// This should be safe if called just once on initialisation, however
+    /// .
-    /// sending data to IO ports tends to have side-effects.
+    pub const unsafe fn new_contiguous(primary_offset: u8) -> Self {
+        unsafe { Self::new(primary_offset, primary_offset + 8) }
+    }
+
+    /// Returns the initialize of this [`ChainedPics`].
+    ///
+    /// # Safety
+    ///
+    /// .
     pub unsafe fn initialize(&mut self) {
         unsafe {
             let mut wait_port: Port<u8> = Port::new(0x80);
@@ -106,12 +112,12 @@ impl ChainedPics {
     }
 
     /// Reads the interrupt masks of both PICs.
-    pub fn read_masks(&mut self) -> [u8; 2] {
+    pub unsafe fn read_masks(&mut self) -> [u8; 2] {
         unsafe { [self.pics[0].read_mask(), self.pics[1].read_mask()] }
     }
 
     /// Writes the interrupt masks of both PICs.
-    pub fn write_masks(&mut self, mask1: u8, mask2: u8) {
+    pub unsafe fn write_masks(&mut self, mask1: u8, mask2: u8) {
         unsafe {
             self.pics[0].write_mask(mask1);
             self.pics[1].write_mask(mask2);
@@ -119,8 +125,8 @@ impl ChainedPics {
     }
 
     /// Disables both PICs by masking all interrupts.
-    pub fn disable(&mut self) {
+    pub unsafe fn disable(&mut self) {
-        self.write_masks(u8::MAX, u8::MAX)
+        unsafe { self.write_masks(u8::MAX, u8::MAX) }
     }
 
     /// Do we handle this interrupt?
@@ -131,7 +137,7 @@ impl ChainedPics {
     /// Figure out which (if any) PICs in our chain need to know about this
     /// interrupt.  This is tricky, because all interrupts from `pics[1]`
     /// get chained through `pics[0]`.
-    pub fn notify_end_of_interrupt(&mut self, interrupt_id: u8) {
+    pub unsafe fn notify_end_of_interrupt(&mut self, interrupt_id: u8) {
         if self.handles_interrupt(interrupt_id) {
             if self.pics[1].handles_interrupt(interrupt_id) {
                 unsafe {

libk/src/lib.rs

@@ -36,12 +36,3 @@ pub use crate::drivers::io::{
     ascii::{_print, _print_log},
     serial::_serial_write,
 };
-
-pub type FoundryAllocator = linked_list_allocator::LockedHeap;
-
-#[global_allocator]
-/// This is now Rust's global allocator, so we can use stuff requiring heap allocations.
-static ALLOCATOR: FoundryAllocator = FoundryAllocator::empty();
-
-pub const HEAP_START: usize = 0x4444_4444_0000;
-pub const HEAP_SIZE: usize = 1024 * 1024 * 1024;

libk/src/resources/font/mod.rs

@@ -1,5 +1,3 @@
-// use libm::include_font;
-
 use libm::include_font;
 
 pub mod ibm_vga_8x16;
@@ -9,18 +7,42 @@ pub static FONT_SPLEEN_8X16: Font =
 
 pub static FONT_CP850_8X16: Font = Font::new(include_font!("./libk/resources/font/cp850-8x16.psf"));
 
-pub struct Font {
+// pub struct Font(pub [[u8; 16]; 512]);
-    pub glyphs: [[u8; 16]; 512],
-}
 
-impl Default for Font {
+pub struct Font {
-    fn default() -> Self {
+    width: usize,
-        Self::new([[0; 16]; 512])
+    height: usize,
-    }
+    length: u16,
+    data: [[u8; 16]; 512],
 }
 
 impl Font {
-    pub const fn new(glyphs: [[u8; 16]; 512]) -> Self {
+    pub const fn new(data: [[u8; 16]; 512]) -> Font {
-        Self { glyphs }
+        Font {
+            width: 8,
+            height: 16,
+            length: data.len() as u16,
+            data,
+        }
+    }
+
+    pub const fn glyph_for(&self, c: u16) -> &[u8] {
+        if c > self.length {
+            return &self.data[0];
+        }
+
+        &self.data[c as usize]
+    }
+
+    pub const fn width(&self) -> usize {
+        self.width
+    }
+
+    pub const fn height(&self) -> usize {
+        self.height
+    }
+
+    pub const fn default() -> &'static Font {
+        &FONT_CP850_8X16
     }
 }

libk/src/std/application.rs

@@ -1,8 +1,8 @@
 use crate::prelude::*;
 
-mod frame;
+pub mod frame;
-mod render;
+pub mod render;
-mod window;
+pub mod window;
 
 pub trait Application {
     type Output;

libk/src/std/application/frame.rs

@@ -1,19 +1,40 @@
+use crate::{drivers::io::framebuffer::colour::Colour, std::maths::geometry::Vec2};
+
 use super::{
     render::{ColouredChar, RenderError},
-    window::Window,
+    window::{self, Window},
 };
-use alloc::vec::Vec;
+use alloc::{vec, vec::Vec};
 
 pub struct Frame<'f> {
-    data: Vec<Vec<ColouredChar>>,
+    data: Vec<Vec<Colour>>,
     window: &'f Window,
 }
 
-impl Frame<'_> {
+impl<'a> Frame<'a> {
+    pub fn new(window: &'a Window) -> Self {
+        Self {
+            data: vec![vec![Colour::Black; window.dimensions().x()]; window.dimensions().y()],
+            window,
+        }
+    }
+
     pub fn render(&self) -> Result<(), RenderError> {
-        let data: Vec<&[ColouredChar]> = 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() {
+            return Err(RenderError::Generic);
+        }
+        self.data[y][x] = color;
+        Ok(())
+    }
+
+    pub const fn dimensions(&self) -> Vec2<usize> {
+        self.window.dimensions()
+    }
 }

libk/src/std/application/window.rs

@@ -1,6 +1,12 @@
-use crate::{prelude::*, std::maths::geometry::Vec2};
+use limine::framebuffer;
 
-use super::render::{ColouredChar, RenderError};
+use crate::{
+    drivers::io::framebuffer::{colour::Colour, display::FRAMEBUFFER_WRITER},
+    prelude::*,
+    std::maths::geometry::Vec2,
+};
+
+use super::render::RenderError;
 
 pub struct Window {
     dimensions: Vec2<usize>,
@@ -21,8 +27,12 @@ impl Window {
         }
     }
 
-    pub fn render(&self, _data: &[&[ColouredChar]]) -> Result<(), RenderError> {
+    pub fn render(&self, _data: &[&[Colour]]) -> Result<(), RenderError> {
-        todo!();
+        // 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);
+        }
+        Ok(())
     }
 
     pub const fn is_bordered(&self) -> bool {

libk/src/std/ascii.rs

@@ -0,0 +1,57 @@
+use crate::{drivers::io::framebuffer::colour::Colour, resources::font::Font};
+
+use super::{
+    application::{frame::Frame, render::RenderError},
+    maths::geometry::Vec2,
+};
+
+pub struct Writer<'a> {
+    font: &'a Font,
+}
+
+impl<'a> Writer<'a> {
+    pub const fn new(font: &'a Font) -> Self {
+        Self { font }
+    }
+
+    pub const fn set_font(&mut self, font: &'a Font) {
+        self.font = font;
+    }
+
+    pub const fn font_size(&self) -> Vec2<usize> {
+        Vec2::new(self.font.width(), self.font.height())
+    }
+
+    pub fn render_glyph(
+        &self,
+        frame: &mut Frame,
+        pos: Vec2<usize>,
+        c: u8,
+        scale: usize,
+    ) -> Result<(), RenderError> {
+        // get a reference to the character glyph from the font.
+        let data: &[u8] = self.font.glyph_for(c as u16);
+
+        if pos.x() + self.font.width() * scale > frame.dimensions().x()
+            || pos.y() + self.font.height() * scale > frame.dimensions().y()
+        {
+            return Err(RenderError::Generic);
+        }
+
+        for (row, line) in data.iter().enumerate().take(self.font.height()) {
+            for col in 0..self.font.width() {
+                let pixel_x: usize = pos.x() + col * scale;
+                let pixel_y: usize = pos.y() + row * scale;
+
+                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)?;
+                        }
+                    }
+                }
+            }
+        }
+        Ok(())
+    }
+}

libk/src/std/maths/geometry.rs

@@ -71,3 +71,9 @@ impl<T: Coordinate> DivAssign<T> for Vec2<T> {
         self.y /= rhs;
     }
 }
+
+impl<T: Coordinate> From<Vec2<T>> for (T, T) {
+    fn from(value: Vec2<T>) -> Self {
+        (value.x, value.y)
+    }
+}

libk/src/std/mod.rs

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

libk/src/util/editor.rs

@@ -0,0 +1,235 @@
+use crate::drivers::io::keyboard::{KeyStroke, get_keystroke_async};
+use crate::prelude::*;
+use crate::resources::font::{FONT_CP850_8X16, FONT_SPLEEN_8X16, 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::std::ascii::Writer;
+use crate::std::maths::geometry::Vec2;
+use alloc::string::ToString;
+
+pub struct Editor {
+    cursor_line: usize,
+    cursor_col: usize,
+
+    mode: Mode,
+    buffer: String,
+    window: Window,
+}
+
+impl Default for Editor {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<'a> Editor {
+    const PADDING: usize = 8;
+
+    pub const fn new() -> Self {
+        Self {
+            cursor_line: 0,
+            cursor_col: 0,
+
+            mode: Mode::Nor,
+            buffer: String::new(),
+            window: Window::new(),
+        }
+    }
+
+    fn render(&'a self) -> Result<Frame<'a>, RenderError> {
+        let mut frame = Frame::new(&self.window);
+        let writer = Writer::new(Font::default());
+
+        let (width, height) = writer.font_size().into();
+
+        let mut col = 0;
+        let mut line = 0;
+        let mut scale = 1;
+
+        for ch in self.buffer.chars() {
+            if ch == '\n' {
+                line += scale;
+                col = 0;
+                scale = 1;
+                continue;
+            }
+
+            if width * (col + 1) > frame.dimensions().x() - 2 * Self::PADDING {
+                line += scale;
+                col = 0;
+            }
+
+            writer.render_glyph(
+                &mut frame,
+                Vec2::new(col * width + Self::PADDING, line * height + Self::PADDING),
+                ch as u8,
+                scale,
+            )?;
+            col += scale;
+        }
+
+        writer.render_glyph(
+            &mut frame,
+            Vec2::new(
+                self.cursor_col * width + Self::PADDING,
+                self.cursor_line * height + Self::PADDING,
+            ),
+            b'_',
+            scale,
+        );
+
+        Ok(frame)
+    }
+
+    #[allow(unused_variables, dead_code, clippy::needless_pass_by_ref_mut)]
+    fn get_lines(&self) -> Vec<&str> {
+        self.buffer.split('\n').collect::<Vec<&str>>()
+    }
+
+    #[allow(unused_variables, dead_code, clippy::needless_pass_by_ref_mut)]
+    fn move_cursor(&mut self, x: i32, y: i32) {
+        self.cursor_line = self
+            .cursor_line
+            .checked_add_signed(y as isize)
+            .unwrap_or(self.cursor_line);
+        self.cursor_col = self
+            .cursor_col
+            .checked_add_signed(x as isize)
+            .unwrap_or(self.cursor_col);
+    }
+
+    #[allow(unused_variables, dead_code, clippy::needless_pass_by_ref_mut)]
+    fn delete_char(&mut self) {
+        let i = self.get_char_idx();
+        self.buffer.remove(i);
+    }
+
+    #[allow(unused_variables, dead_code, clippy::needless_pass_by_ref_mut)]
+    fn insert_char(&mut self, c: char) {
+        let i = self.get_char_idx();
+        self.buffer.insert(i, c);
+    }
+
+    #[allow(unused_variables, dead_code, clippy::needless_pass_by_ref_mut)]
+    fn splitline(&mut self) {
+        let i = self.get_char_idx();
+        self.buffer.insert(i, '\n');
+    }
+
+    fn get_char_idx(&self) -> usize {
+        let frame = Frame::new(&self.window);
+        let writer = Writer::new(Font::default());
+        let (width, _height) = writer.font_size().into();
+
+        let mut col = 0;
+        let mut line = 0;
+        let mut scale = 1;
+
+        for (i, ch) in self.buffer.chars().enumerate() {
+            if ch == '\n' {
+                line += scale;
+                col = 0;
+                scale = 1;
+                continue;
+            }
+
+            if width * (col + 1) > frame.dimensions().x() - 2 * Self::PADDING {
+                line += scale;
+                col = 0;
+            }
+
+            if col == self.cursor_col && line == self.cursor_line {
+                return i;
+            }
+
+            col += scale;
+        }
+
+        0
+    }
+}
+
+impl Application for Editor {
+    type Output = ();
+    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();
+
+        self.buffer = "Hello world, this is a test init. idk test \n ewntuiewi gjk gfdfg gndf ngdfgnmdfg ndfgmndfg gdfndfnkg njkdgjkndfjnkg ngnjfgnfgnfg fgn fn gfj gnfg jnfgjfngjk fgnjfgnjk jnkdgjnkdfg gfnd njkgdfgjn d fjnkgjkndfgjkndfgjn gndfjnk njkgdfng jnkfgdjknd jnfkgnjk".to_string();
+
+        loop {
+            if let Err(_err) = self.render().and_then(|frame| frame.render()) {
+                // TODO: Handle error
+                return Err(Error::ApplicationFailed("Rendering failed".to_string()));
+            }
+
+            let keystroke = get_keystroke_async().await;
+
+            match self.mode {
+                Mode::Nor => match keystroke {
+                    KeyStroke::Char('i') => self.mode = Mode::Ins,
+                    KeyStroke::Char('`') => return Ok(()),
+                    _ => {}
+                },
+                Mode::Ins => {
+                    match keystroke {
+                        KeyStroke::Char(c) => {
+                            match c {
+                                // escape
+                                '\x1B' => self.mode = Mode::Nor,
+                                // delete
+                                '\x7F' => self.delete_char(),
+                                // backspace
+                                '\x08' => {
+                                    self.move_cursor(-1, 0);
+                                    self.delete_char();
+                                }
+                                // enter
+                                '\n' => self.splitline(),
+                                _ => {
+                                    self.insert_char(c);
+                                    self.move_cursor(1, 0);
+                                }
+                            }
+                        }
+                        KeyStroke::Left => {
+                            serial_println!("Left\n");
+                            self.move_cursor(-1, 0);
+                        }
+                        KeyStroke::Right => {
+                            serial_println!("Right\n");
+                            self.move_cursor(1, 0);
+                        }
+                        KeyStroke::Up => {
+                            serial_println!("Up\n");
+                            self.move_cursor(0, -1);
+                        }
+                        KeyStroke::Down => {
+                            serial_println!("Down\n");
+                            self.move_cursor(0, 1);
+                        }
+                        KeyStroke::None => {}
+                        _ => {}
+                    }
+                }
+            }
+        }
+    }
+}
+
+pub enum Mode {
+    Nor,
+    Ins,
+}
+
+impl core::fmt::Display for Mode {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Self::Nor => write!(f, "Normal"),
+            Self::Ins => write!(f, "Insert"),
+        }
+    }
+}

libk/src/util/mod.rs

@@ -1 +1,2 @@
+pub mod editor;
 pub mod shell;

libk/src/util/shell.rs

@@ -1,6 +1,11 @@
 // use x86_64::registers::rflags::read;
 
-use crate::{drivers::io::ascii::clear_screen, prelude::stdin::read_line, print, println};
+use alloc::vec::Vec;
+
+use crate::{
+    drivers::io::ascii::clear_screen, prelude::stdin::read_line, print, println,
+    std::application::Application, util::editor::Editor,
+};
 
 static FETCH: &str = "
         $$$$$$$$\\                                  $$\\                     
@@ -31,6 +36,10 @@ pub async fn shell() {
             "fetch" => {
                 println!("{}", FETCH);
             }
+            "editor" => {
+                let mut editor = Editor::new();
+                editor.run(Vec::new()).await.unwrap();
+            }
             "clear" => clear_screen(),
             _ => {
                 println!("Unknown command: {}", line);

libm/rust-toolchain.toml

@@ -0,0 +1,3 @@
+[toolchain]
+channel = "nightly"
+targets = ["x86_64-linux-gnu"]

scripts/run_debug.sh

@@ -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" \