Megacommit to move some memory code into kernel crate

README.md

@@ -45,4 +45,8 @@ Alternatively, you may disable using a UEFI firmware with qemu like so:
 USE_LEGACY_BIOS=1 cargo run
 ```
 
+## Debugging
+
+See [debugging](docs/Debugging/DEBUGGING.md) for some help with this, including commands to help with disassembly.
+
 If you have any other issues, feel free to create an issue or a PR.

debug.txt

@@ -0,0 +1,17 @@
+ Running kernel in debug mode.
+info: Creating build directory structure
+info: Copying files to ISO root
+  Copying: /home/fantasypvp/Projects/OSdev/FoundryOS/build/target/x86_64-kernel/debug/kernel to /home/fantasypvp/Projects/OSdev/FoundryOS/build/iso_root/boot/kernel
+  Copying: /home/fantasypvp/Projects/OSdev/FoundryOS/config/limine.conf to /home/fantasypvp/Projects/OSdev/FoundryOS/build/iso_root/boot/limine/limine.conf
+  Copying: /home/fantasypvp/Projects/OSdev/FoundryOS/build/limine/limine-bios-cd.bin to /home/fantasypvp/Projects/OSdev/FoundryOS/build/iso_root/boot/limine/
+  Copying: /home/fantasypvp/Projects/OSdev/FoundryOS/build/limine/limine-uefi-cd.bin to /home/fantasypvp/Projects/OSdev/FoundryOS/build/iso_root/boot/limine/
+  Copying: /home/fantasypvp/Projects/OSdev/FoundryOS/build/limine/limine-bios.sys to /home/fantasypvp/Projects/OSdev/FoundryOS/build/iso_root/boot/limine/
+  Copying: /home/fantasypvp/Projects/OSdev/FoundryOS/build/limine/BOOTX64.EFI to /home/fantasypvp/Projects/OSdev/FoundryOS/build/iso_root/EFI/BOOT/
+  Copying: /home/fantasypvp/Projects/OSdev/FoundryOS/build/limine/BOOTIA32.EFI to /home/fantasypvp/Projects/OSdev/FoundryOS/build/iso_root/EFI/BOOT/
+Building: bootable ISO image
+info: Installing Limine bootloader
+info: KVM acceleration enabled
+info: Running OS in QEMU...
+[=3h[=3h[=3hBdsDxe: loading Boot0001 "UEFI QEMU DVD-ROM QM00005 " from PciRoot(0x0)/Pci(0x1F,0x2)/Sata(0x2,0xFFFF,0x0)
+BdsDxe: starting Boot0001 "UEFI QEMU DVD-ROM QM00005 " from PciRoot(0x0)/Pci(0x1F,0x2)/Sata(0x2,0xFFFF,0x0)
+map worked!got apic base

docs/.obsidian/community-plugins.json

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

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

@@ -1,12 +0,0 @@
-{
-  "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

@@ -3,6 +3,26 @@
     "id": "20da7b1c0adc4114",
     "type": "split",
     "children": [
+      {
+        "id": "a20540b7c1ddbfca",
+        "type": "tabs",
+        "children": [
+          {
+            "id": "e1fb15cab546d0b6",
+            "type": "leaf",
+            "state": {
+              "type": "markdown",
+              "state": {
+                "file": "Usage/Building The Kernel.md",
+                "mode": "source",
+                "source": false
+              },
+              "icon": "lucide-file",
+              "title": "Building The Kernel"
+            }
+          }
+        ]
+      },
       {
         "id": "6bf1f87bf81a3031",
         "type": "tabs",
@@ -13,32 +33,12 @@
             "state": {
               "type": "markdown",
               "state": {
-                "file": "Planning & To-Dos.md",
+                "file": "Usage/Building The Kernel.md",
-                "mode": "source",
-                "source": false
-              },
-              "icon": "lucide-file",
-              "title": "Planning & To-Dos"
-            }
-          }
-        ]
-      },
-      {
-        "id": "c178a2dff57ae0aa",
-        "type": "tabs",
-        "children": [
-          {
-            "id": "6d395e6a4c72e1c8",
-            "type": "leaf",
-            "state": {
-              "type": "markdown",
-              "state": {
-                "file": "Planning & To-Dos.md",
                 "mode": "preview",
                 "source": false
               },
               "icon": "lucide-file",
-              "title": "Planning & To-Dos"
+              "title": "Building The Kernel"
             }
           }
         ]
@@ -73,7 +73,7 @@
             "state": {
               "type": "search",
               "state": {
-                "query": "tag:#Threading",
+                "query": "tag:#usage",
                 "matchingCase": false,
                 "explainSearch": false,
                 "collapseAll": false,
@@ -94,12 +94,12 @@
               "title": "Bookmarks"
             }
           }
-        ],
+        ]
-        "currentTab": 1
       }
     ],
     "direction": "horizontal",
-    "width": 200
+    "width": 200,
+    "collapsed": true
   },
   "right": {
     "id": "baa2a8e61b737fa6",
@@ -191,15 +191,8 @@
   },
   "active": "add883d295e04659",
   "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/Debugging/DEBUGGING.md

@@ -0,0 +1,16 @@
+# Debugging the Kernel
+
+Here we will add some helpful tips on debugging the kernel.
+
+## Disassembling a public function
+
+To disassemble a public function, first we need a symbol in the public symbol table, so start by making the function fully public (including any parent modules). Do this as though you are trying to make a public function for a library crate (this includes the `kernel` crate). Simply mark the function and any parent modules as public, up until the point of [lib.rs (kernel link)](../../kernel/src/lib.rs).
+
+Then, we need to find the specific demangled symbol to disassemble, because the default objdump output can be very verbose.
+
+```sh
+# Change as required, I pipe to less and /SEARCH FOR FUNCTION HERE.
+nm --demangle ./build/target/x86_64-kernel/debug/kernel | less
+# Now just paste the symbol where it says YOUR_SYMBOL_HERE and profit. Use -Mintel for Intel assembly syntax.
+objdump -Matt --source --line-numbers --visualize-jumps ./build/target/x86_64-kernel/debug/kernel --demangle=rust --disassemble="YOUR_SYMBOL_HERE"
+```

docs/Planning & To-Dos.md

@@ -1,109 +0,0 @@
-
-> [!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

@@ -1,41 +0,0 @@
-{
-	"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

@@ -1,16 +0,0 @@
-- 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

@@ -0,0 +1,113 @@
+#![allow(unused)] // TODO: Remove this when ready.
+use core::arch::x86_64::__cpuid;
+
+use x86_64::{
+    PhysAddr, VirtAddr,
+    structures::paging::{Mapper, Size4KiB},
+};
+
+use crate::serial_print;
+
+use super::{cpu::model_specific_registers::*, mem::memmap::PHYSICAL_MEMORY_OFFSET};
+
+const IA32_APIC_BASE_MSR: u32 = 0x1b;
+const IA32_APIC_BASE_MSR_BSP: u64 = 0x100;
+const IA32_APIC_BASE_MSR_ENABLE: u64 = 0x800;
+const IA32_APIC_BASE_MSR_DISABLE: u64 = !IA32_APIC_BASE_MSR_ENABLE;
+
+const CPUID_FEAT_EDX_APIC: u64 = 1 << 9; // the cpuid instruction will return this flag if it supports APIC
+
+// const APIC_VIRTUAL_ADDRESS: Lazy<VirtAddr> = Lazy::new(|| {
+//     let apic_base = get_apic_base();
+//     let virt_addr = unsafe { phys_to_virt(apic_base) };
+
+//     virt_addr
+// });
+
+fn set_apic_base_enable(apic: PhysAddr) {
+    let rax = (apic.as_u64() & 0xfffff0000) | IA32_APIC_BASE_MSR_ENABLE;
+    cpu_set_msr(IA32_APIC_BASE_MSR, rax);
+}
+
+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);
+}
+
+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) {
+    let apic_base = apic_base.as_u64();
+    let reg_addr = (apic_base & 0xFFFFF0000) + reg as u64;
+    unsafe { *(reg_addr as *mut u32) = value };
+}
+
+fn read_apic_register(apic_base: &VirtAddr, reg: u8) -> 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) }
+}
+
+pub fn check_apic() -> bool {
+    let res = unsafe { __cpuid(1) };
+    res.edx as u64 & CPUID_FEAT_EDX_APIC != 0
+}
+
+#[inline(always)]
+unsafe fn phys_to_virt(phys: PhysAddr) -> VirtAddr {
+    let phys = phys.as_u64();
+    phys.checked_add(*PHYSICAL_MEMORY_OFFSET).map_or_else(
+        || {
+            serial_print!("THIS IS A PROBLEM");
+            panic!("overflow")
+        },
+        |virt| {
+            serial_print!("map worked!");
+            VirtAddr::new(virt)
+        },
+    )
+}
+
+pub fn enable_apic(
+    _mapper: &mut impl Mapper<Size4KiB>,
+    // TODO: Fix this function.
+    // frame_allocator: &mut FoundryOSFrameAllocator,
+) {
+    unimplemented!();
+
+    // let apic_phys_addr = get_apic_base();
+    // set_apic_base_enable(apic_phys_addr);
+    // map virt address of apic
+
+    // 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, frame_allocator) {
+    //         Ok(_) => {}
+    //         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);
+
+    // serial_print!("ok2");
+
+    // write_apic_register(&apic_virt, 0xF0, reg | 0x100);
+}
+
+pub struct Apic {}
+
+pub enum ApicVector {}

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,6 @@
-use libk::drivers::apic::enable_apic;
+// use libk::drivers::mem::{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 spin::{Lazy, Mutex};
@@ -52,14 +51,22 @@ impl InterruptIndex {
 
 pub fn init_idt() {
     IDT.load();
-    // enable_apic();
+}
-    // TODO: fix apic
+
+pub fn enable_pic() {
     unsafe {
         PICS.lock().initialize();
         PICS.lock().write_masks(0xfc, 0xff);
     }
 }
 
+#[expect(unused)]
+pub fn disable_pic() {
+    unsafe {
+        PICS.lock().disable();
+    }
+}
+
 extern "x86-interrupt" fn breakpoint_handler(stack_frame: InterruptStackFrame) {
     serial_println!("Exception: Breakpoint\n{:#?}", stack_frame);
     println_log!("Exception: Breakpoint\n{:#?}", stack_frame);
@@ -115,13 +122,32 @@ extern "x86-interrupt" fn timer_interrupt_handler(_stack_frame: InterruptStackFr
 }
 
 extern "x86-interrupt" fn page_fault_handler(
-    stack_frame: InterruptStackFrame,
+    _stack_frame: InterruptStackFrame,
-    error_code: PageFaultErrorCode,
+    _error_code: PageFaultErrorCode,
 ) {
-    serial_println!("Exception: Page Fault");
+    todo!("Get this working again.")
-    serial_println!("Accessed Address: {:?}", Cr2::read());
+    // serial_println!("Exception: Page Fault");
-    serial_println!("Error Code: {:?}", error_code);
+    // serial_println!("Accessed Address: {:?}", Cr2::read());
-    serial_println!("{:#?}", stack_frame);
+    // serial_println!("Error Code: {:?}", error_code);
+    // serial_println!("{:#?}", stack_frame);
 
-    crate::hcf();
+    // 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());
+
+    //     unsafe {
+    //         let mut mapper = OFFSET_PAGE_TABLE.get().unwrap().lock();
+
+    //         match mapper.map_to(page, frame, flags, &mut *f) {
+    //             Ok(_) => {}
+    //             Err(why) => panic!("failed to map page: {:?}", why),
+    //         }
+    //     }
+    //     MapperFlushAll::new().flush_all();
+    // } else {
+    //     panic!("failed to get frame allocator");
+    // }
 }

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

@@ -14,6 +14,10 @@ static MEMORY_MAP_REQUEST: MemoryMapRequest = MemoryMapRequest::new();
 #[unsafe(link_section = ".requests")]
 static HIGHER_HALF_DIRECT_MAP_REQUEST: HhdmRequest = HhdmRequest::new();
 
+#[used]
+#[unsafe(link_section = ".requests")]
+static KERNEL_ADDRESS_REQUEST: KernelAddressRequest = KernelAddressRequest::new();
+
 /// ```rs
 /// let virt_addr = phys_addr + offset;
 /// let phys_addr = virt_addr - offset; // (given VA is in the HHDM). Do not use for executable code.
@@ -25,10 +29,6 @@ pub static PHYSICAL_MEMORY_OFFSET: Lazy<u64> = Lazy::new(|| {
         .offset()
 });
 
-#[used]
-#[unsafe(link_section = ".requests")]
-static KERNEL_ADDRESS_REQUEST: KernelAddressRequest = KernelAddressRequest::new();
-
 /// Converts virtual addresses in the kernel to a physical address like this:
 /// ```rs
 /// let phys_addr = virt_addr - virtual_base + physical_base;

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

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

kernel/src/arch/x86_64/memory.rs

@@ -1,141 +0,0 @@
-// use lib_alloc::allocator::FoundryAllocator;
-use limine::{memory_map::EntryType, response::MemoryMapResponse};
-use x86_64::{
-    PhysAddr,
-    VirtAddr,
-    // addr,
-    registers::control::Cr3,
-    structures::paging::{
-        // page_table::FrameError,
-        FrameAllocator,
-        OffsetPageTable,
-        PageTable,
-        PhysFrame,
-        Size4KiB,
-    },
-};
-
-/// 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 unsafe fn init(physical_memory_offset: VirtAddr) -> OffsetPageTable<'static> {
-    unsafe {
-        let l4_table = active_l4_table(physical_memory_offset);
-        OffsetPageTable::new(l4_table, physical_memory_offset)
-    }
-}
-
-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 const unsafe fn init(memory_map: &'static MemoryMapResponse) -> Self {
-        Self {
-            memory_map,
-            next: 0,
-        }
-    }
-
-    /// 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/mod.rs

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

kernel/src/lib.rs

@@ -13,14 +13,14 @@
 
 extern crate alloc;
 
+// use arch::x86_64::apic::enable_apic;
 use core::arch::asm;
+// use libk::drivers::mem::pmm;
 use limine::BaseRevision;
 
-use libk::drivers::kalloc::allocator::init_heap;
+// use libk::drivers::alloc::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 +56,9 @@ pub fn boot() -> Result<(), &'static str> {
         return Err("base revision not supported");
     }
 
-    use arch::x86_64::{gdt, interrupts, memmap, memory};
+    use arch::x86_64::{gdt, interrupts, mem::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() {
@@ -75,21 +75,34 @@ pub fn boot() -> Result<(), &'static str> {
     interrupts::init_idt();
     println_log!("[Success]");
 
-    print_log!("    Setting Up Page Table... ");
+    print_log!("    Initialising Memory Subsystem... ");
-    let mut frame_allocator = unsafe { memory::FoundryOSFrameAllocator::init(memory_map) };
+    // let physical_memory_offset = VirtAddr::new(*memmap::PHYSICAL_MEMORY_OFFSET);
+    // pmm::init_page_table(physical_memory_offset);
     println_log!("[Success]");
 
-    print_log!("    Initialising Memory Subsystem... ");
+    print_log!("    Setting Up Page Table... ");
-    let physical_memory_offset = VirtAddr::new(*memmap::PHYSICAL_MEMORY_OFFSET);
+    // pmm::init_frame_allocator(memory_map);
-    let mut l4_table = unsafe { memory::init(physical_memory_offset) };
     println_log!("[Success]");
 
     print_log!("    Initialising Heap... ");
-    if init_heap(&mut l4_table, &mut frame_allocator).is_err() {
+    // TODO: Reenable the heap.
-        return Err("Failed to initialise heap: error");
+    // if init_heap().is_err() {
-    }
+    // return Err("Failed to initialise heap: error");
+    // }
     println_log!("[Success]");
 
+    print_log!("    Enabling PICs... ");
+    interrupts::enable_pic();
+    println_log!("[Success]");
+
+    // print_log!("    Disabling PICs... ");
+    // interrupts::disable_pic();
+    // println_log!("[Success]");
+    //
+    // print_log!("    Initialising APIC");
+    // enable_apic(&mut l4_table, &mut frame_allocator);
+    // println_log!("[Success]");
+
     print_log!("    Enabling Interrupts... ");
     x86_64::instructions::interrupts::enable();
     println_log!("[Success]");

kernel/src/main.rs

@@ -3,11 +3,10 @@
 
 extern crate alloc;
 
-use alloc::vec;
 use libk::{
     drivers::{
         async_io::task::{Executor, Task},
-        io::{self, framebuffer::colour::Colour},
+        io,
     },
     prelude::*,
     util::shell::shell,
@@ -28,16 +27,14 @@ extern "C" fn kmain() -> ! {
     println!("Dimensions: {}x{} (px)", dimensions2.0, dimensions2.1);
     println!("Dimensions: {}x{} (chars)", dimensions.0, dimensions.1);
 
-    let vector = vec![0; 100];
-    println!("vec 100 works");
-    let vector2 = vec![0; 1000];
-    println!("vec 1000 works");
-    let vector3 = vec![0; 10000];
-    println!("vec 10000 works");
-    let vector4 = vec![vec![Colour::Black; 1000]; 1000];
-    println!("vec 100000 works");
-
     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();
 }

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/apic/mod.rs

@@ -1,49 +0,0 @@
-use core::arch::x86_64::__cpuid;
-
-use x86_64::{PhysAddr, instructions::port::Port, registers::model_specific::Msr};
-
-use super::cpu::model_specific_registers::*;
-
-const IA32_APIC_BASE_MSR: u32 = 0x1b;
-const IA32_APIC_BASE_MSR_BSP: u64 = 0x100;
-const IA32_APIC_BASE_MSR_ENABLE: u64 = 0x800;
-
-const CPUID_FEAT_EDX_APIC: u64 = 1 << 9; // the cpuid instruction will return this flag if it supports APIC
-
-fn set_apic_base(apic: PhysAddr) {
-    let rax = (apic.as_u64() & 0xfffff0000) | IA32_APIC_BASE_MSR_ENABLE;
-    cpu_set_msr(IA32_APIC_BASE_MSR, rax);
-}
-
-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(reg: u8, value: u32) {
-    let apic_base = get_apic_base().as_u64();
-    let reg_addr = (apic_base & 0xFFFFF0000) + reg as u64;
-    unsafe { *(reg_addr as *mut u32) = value };
-}
-
-fn read_apic_register(reg: u8) -> u32 {
-    let apic_base = get_apic_base().as_u64();
-    let reg_addr = (apic_base & 0xFFFFF0000) + reg as u64;
-    unsafe { *(reg_addr as *const u32) }
-}
-
-pub fn check_apic() -> bool {
-    let res = unsafe { __cpuid(1) };
-    res.edx as u64 & CPUID_FEAT_EDX_APIC != 0
-}
-
-pub fn enable_apic() {
-    set_apic_base(get_apic_base());
-
-    write_apic_register(0xF0, read_apic_register(0xF0) | 0x100);
-}
-
-pub struct Apic {}
-
-pub enum ApicVector {}

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.glyph_for(c as u16);
+        let data: &[u8] = &self.font.glyphs[c as usize];
 
         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,16 +61,9 @@ impl FramebufferWriter {
         }
     }
 
-    pub fn render_frame(&self, buffer: &[&[Colour]]) {
+    pub fn render_frame(&self, buffer: &[Colour; 1280 * 800]) {
-        // TODO: this should return errors
+        for (y, row) in buffer.chunks(1280).enumerate() {
-        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

@@ -1,45 +0,0 @@
-use linked_list_allocator::LockedHeap;
-use x86_64::{
-    VirtAddr,
-    structures::paging::{
-        FrameAllocator, Mapper, Page, PageTableFlags, Size4KiB, mapper::MapToError,
-    },
-};
-
-/// We are currently using a linked list heap allocator which uses our underlying page allocator.
-pub type FoundryAllocator = 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 = 1000 * 1024;
-
-/// Sets up the heap using the backing page frame allocator.
-pub fn init_heap(
-    mapper: &mut impl Mapper<Size4KiB>,
-    frame_allocator: &mut impl FrameAllocator<Size4KiB>,
-) -> Result<(), MapToError<Size4KiB>> {
-    let range = {
-        let heap_start = VirtAddr::new(HEAP_START as u64);
-        let heap_end = heap_start + HEAP_SIZE as u64 - 1u64;
-        let heap_start_page = Page::<Size4KiB>::containing_address(heap_start);
-        let heap_end_page = Page::<Size4KiB>::containing_address(heap_end);
-        Page::range_inclusive(heap_start_page, heap_end_page)
-    };
-
-    for page in range {
-        let frame = frame_allocator
-            .allocate_frame()
-            .ok_or(MapToError::FrameAllocationFailed)?;
-        let flags = PageTableFlags::PRESENT | PageTableFlags::WRITABLE;
-        unsafe { mapper.map_to(page, frame, flags, frame_allocator)?.flush() };
-    }
-
-    unsafe {
-        ALLOCATOR.lock().init(HEAP_START as *mut u8, HEAP_SIZE);
-    }
-
-    Ok(())
-}

libk/src/drivers/kalloc/mod.rs

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

libk/src/drivers/mod.rs

@@ -1,7 +1,3 @@
-pub mod io;
-pub mod kalloc;
-
-pub mod apic;
 pub mod async_io;
-pub mod cpu;
+pub mod io;
 pub mod pic;

libk/src/drivers/pic.rs

@@ -40,8 +40,8 @@ pub struct ChainedPics {
 }
 
 impl ChainedPics {
-    pub const unsafe fn new(offset1: u8, offset2: u8) -> Self {
+    pub const fn new(offset1: u8, offset2: u8) -> Self {
-        ChainedPics {
+        Self {
             pics: [
                 Pic {
                     offset: offset1,
@@ -57,20 +57,14 @@ impl ChainedPics {
         }
     }
 
-    /// .
+    pub const fn new_contiguous(primary_offset: u8) -> Self {
-    ///
+        Self::new(primary_offset, primary_offset + 8)
-    /// # Safety
-    ///
-    /// .
-    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
     ///
-    /// .
+    /// This should be safe if called just once on initialisation, however
+    /// sending data to IO ports tends to have side-effects.
     pub unsafe fn initialize(&mut self) {
         unsafe {
             let mut wait_port: Port<u8> = Port::new(0x80);
@@ -112,12 +106,12 @@ impl ChainedPics {
     }
 
     /// Reads the interrupt masks of both PICs.
-    pub unsafe fn read_masks(&mut self) -> [u8; 2] {
+    pub 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 unsafe fn write_masks(&mut self, mask1: u8, mask2: u8) {
+    pub fn write_masks(&mut self, mask1: u8, mask2: u8) {
         unsafe {
             self.pics[0].write_mask(mask1);
             self.pics[1].write_mask(mask2);
@@ -125,8 +119,8 @@ impl ChainedPics {
     }
 
     /// Disables both PICs by masking all interrupts.
-    pub unsafe fn disable(&mut self) {
+    pub fn disable(&mut self) {
-        unsafe { self.write_masks(u8::MAX, u8::MAX) }
+        self.write_masks(u8::MAX, u8::MAX)
     }
 
     /// Do we handle this interrupt?
@@ -137,7 +131,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 unsafe fn notify_end_of_interrupt(&mut self, interrupt_id: u8) {
+    pub 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,3 +36,12 @@ 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,3 +1,5 @@
+// use libm::include_font;
+
 use libm::include_font;
 
 pub mod ibm_vga_8x16;
@@ -7,42 +9,18 @@ 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 [[u8; 16]; 512]);
-
 pub struct Font {
-    width: usize,
+    pub glyphs: [[u8; 16]; 512],
-    height: usize,
+}
-    length: u16,
+
-    data: [[u8; 16]; 512],
+impl Default for Font {
+    fn default() -> Self {
+        Self::new([[0; 16]; 512])
+    }
 }
 
 impl Font {
-    pub const fn new(data: [[u8; 16]; 512]) -> Font {
+    pub const fn new(glyphs: [[u8; 16]; 512]) -> Self {
-        Font {
+        Self { glyphs }
-            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::*;
 
-pub mod frame;
+mod frame;
-pub mod render;
+mod render;
-pub mod window;
+mod window;
 
 pub trait Application {
     type Output;

libk/src/std/application/frame.rs

@@ -1,40 +1,19 @@
-use crate::{drivers::io::framebuffer::colour::Colour, std::maths::geometry::Vec2};
-
 use super::{
     render::{ColouredChar, RenderError},
-    window::{self, Window},
+    window::Window,
 };
-use alloc::{vec, vec::Vec};
+use alloc::vec::Vec;
 
 pub struct Frame<'f> {
-    data: Vec<Vec<Colour>>,
+    data: Vec<Vec<ColouredChar>>,
     window: &'f Window,
 }
 
-impl<'a> Frame<'a> {
+impl Frame<'_> {
-    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<&[Colour]> = self.data.iter().map(|v| v.as_slice()).collect::<Vec<_>>();
+        let data: Vec<&[ColouredChar]> = 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,12 +1,6 @@
-use limine::framebuffer;
+use crate::{prelude::*, std::maths::geometry::Vec2};
 
-use crate::{
+use super::render::{ColouredChar, RenderError};
-    drivers::io::framebuffer::{colour::Colour, display::FRAMEBUFFER_WRITER},
-    prelude::*,
-    std::maths::geometry::Vec2,
-};
-
-use super::render::RenderError;
 
 pub struct Window {
     dimensions: Vec2<usize>,
@@ -27,12 +21,8 @@ impl Window {
         }
     }
 
-    pub fn render(&self, _data: &[&[Colour]]) -> Result<(), RenderError> {
+    pub fn render(&self, _data: &[&[ColouredChar]]) -> Result<(), RenderError> {
-        // TODO: error handling!! the kernel should return an error in some cases
+        todo!();
-        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

@@ -1,59 +0,0 @@
-use alloc::vec::Vec;
-
-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,9 +71,3 @@ 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,4 +1,3 @@
 pub mod application;
-pub mod ascii;
 pub mod io;
 pub mod maths;

libk/src/util/editor.rs

@@ -1,174 +0,0 @@
-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 = Self::PADDING;
-        let mut line = Self::PADDING;
-        let mut scale = 1;
-
-        for ch in self.buffer.chars() {
-            if ch == '\n' {
-                line += scale * height;
-                col = Self::PADDING;
-                scale = 1;
-                continue;
-            }
-
-            if width * scale + col > frame.dimensions().x() {
-                line += scale * height;
-                col = Self::PADDING;
-            }
-
-            writer.render_glyph(&mut frame, Vec2::new(col, line), ch as u8, scale)?;
-            col += scale * width;
-        }
-
-        Ok(frame)
-    }
-
-    fn get_lines(&self) -> Vec<&str> {
-        self.buffer.split('\n').collect::<Vec<&str>>();
-        todo!()
-    }
-
-    #[allow(unused_variables, dead_code, clippy::needless_pass_by_ref_mut)]
-    fn move_cursor(&mut self, x: i32, y: i32) {
-        todo!()
-    }
-
-    #[allow(unused_variables, dead_code, clippy::needless_pass_by_ref_mut)]
-    fn delete_char(&mut self) {
-        todo!()
-    }
-
-    #[allow(unused_variables, dead_code, clippy::needless_pass_by_ref_mut)]
-    fn insert_char(&mut self, c: char) {
-        todo!()
-    }
-
-    #[allow(unused_variables, dead_code, clippy::needless_pass_by_ref_mut)]
-    fn splitline(&mut self) {
-        todo!()
-    }
-}
-
-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 => {
-                            self.move_cursor(-1, 0);
-                        }
-                        KeyStroke::Right => {
-                            self.move_cursor(1, 0);
-                        }
-                        KeyStroke::Up => {
-                            self.move_cursor(0, -1);
-                        }
-                        KeyStroke::Down => {
-                            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,2 +1 @@
-pub mod editor;
 pub mod shell;

libk/src/util/shell.rs

@@ -1,11 +1,6 @@
 // use x86_64::registers::rflags::read;
 
-use alloc::vec::Vec;
+use crate::{drivers::io::ascii::clear_screen, prelude::stdin::read_line, print, println};
-
-use crate::{
-    drivers::io::ascii::clear_screen, prelude::stdin::read_line, print, println,
-    std::application::Application, util::editor::Editor,
-};
 
 static FETCH: &str = "
         $$$$$$$$\\                                  $$\\                     
@@ -36,10 +31,6 @@ 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);

scripts/build.sh

@@ -0,0 +1,109 @@
+#!/bin/bash
+
+# Colors
+GREEN='\033[0;32m'
+BLUE='\033[0;34m'
+YELLOW='\033[0;33m'
+RED='\033[0;31m'
+BOLD='\033[1m'
+NC='\033[0m' # No Color
+
+# Error handling
+set -e
+trap 'echo -e "${RED}${BOLD}error${NC}: build failed" >&2' ERR
+
+# Get absolute path to project root
+project_root=$(cd "$script_dir/.." &>/dev/null && pwd)
+build_dir="$project_root/build"
+iso_root="$build_dir/iso_root"
+
+# Logging functions
+info() {
+    echo -e "${BLUE}${BOLD}info${NC}: $1"
+}
+
+compiling() {
+    echo -e "${GREEN}${BOLD}Compiling${NC}: $1"
+}
+
+warning() {
+    echo -e "${YELLOW}${BOLD}warning${NC}: $1" >&2
+}
+
+building() {
+    echo -e "${GREEN}${BOLD}Building${NC}: $1"
+}
+
+copying() {
+    echo -e "${GREEN}${BOLD}  Copying${NC}: $1 to $2"
+}
+
+error() {
+    echo -e "${RED}${BOLD}error${NC}: $1" >&2
+    exit 1
+}
+
+copy_file() {
+    copying $1 $2
+    cp "$1" "$2" || error $3
+}
+
+# Check if we're running tests
+if [[ $1 == *"deps"* ]]; then
+    kernel_path="$1"
+else
+    # Build the kernel normally
+    cd "$project_root"
+    # cargo build
+    kernel_path="$build_dir/target/x86_64-kernel/debug/kernel"
+fi
+
+# Check for required tools
+check_tools() {
+    local missing=0
+    for tool in xorriso git qemu-system-x86_64; do
+        if ! command -v $tool >/dev/null 2>&1; then
+            error "required tool '$tool' is not installed"
+            missing=1
+        fi
+    done
+    if [ $missing -eq 1 ]; then
+        error "missing required tools"
+    fi
+}
+
+# Create build directory structure
+info "Creating build directory structure"
+mkdir -p "$iso_root/boot/limine"
+mkdir -p "$iso_root/EFI/BOOT"
+
+# Clone Limine if needed
+if [ ! -d "$build_dir/limine" ]; then
+    compiling "limine bootloader"
+    cd "$build_dir"
+    git clone https://github.com/limine-bootloader/limine.git --branch=v9.x-binary --depth=1 "$build_dir/limine" || error "failed to clone limine"
+    make -C "$build_dir/limine" || error "failed to build limine"
+    cd "$project_root"
+fi
+
+# Copy files
+info "Copying files to ISO root"
+copy_file "$kernel_path" "$iso_root/boot/kernel" "failed to copy kernel"
+copy_file "$project_root/config/limine.conf" "$iso_root/boot/limine/limine.conf" "failed to copy limine config"
+copy_file "$build_dir/limine/limine-bios-cd.bin" "$iso_root/boot/limine/" "failed to copy limine-bios-cd.bin"
+copy_file "$build_dir/limine/limine-uefi-cd.bin" "$iso_root/boot/limine/" "failed to copy limine-uefi-cd.bin"
+copy_file "$build_dir/limine/limine-bios.sys" "$iso_root/boot/limine/" "failed to copy limine-bios.sys"
+copy_file "$build_dir/limine/BOOTX64.EFI" "$iso_root/EFI/BOOT/" "failed to copy BOOTX64.EFI"
+copy_file "$build_dir/limine/BOOTIA32.EFI" "$iso_root/EFI/BOOT/" "failed to copy BOOTIA32.EFI"
+
+# Create ISO
+building "bootable ISO image"
+xorriso -as mkisofs -R -r -J -b boot/limine/limine-bios-cd.bin \
+        -no-emul-boot -boot-load-size 4 -boot-info-table -hfsplus \
+        -apm-block-size 2048 --efi-boot boot/limine/limine-uefi-cd.bin \
+        -efi-boot-part --efi-boot-image --protective-msdos-label \
+        "$iso_root" -o "$build_dir/image.iso" || error "failed to create ISO"
+
+# Install Limine
+info "Installing Limine bootloader"
+"$build_dir/limine/limine" bios-install "$build_dir/image.iso" || error "failed to install limine"

scripts/flash_iso.sh

@@ -0,0 +1,20 @@
+#!/bin/bash
+
+script_dir=$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" &>/dev/null && pwd)
+
+source scripts/build.sh
+
+warning "This script will OVERWRITE whatever media you throw at it\nwith the built ISO."
+
+info "sudo ./hardware.sh /dev/yourdisk"
+
+if ! echo "$1" | grep -q "/dev"; then
+    error "invalid device"
+fi
+
+read -p "Confirm (y/n): " confirmation
+if [ "$confirmation" != "y" ]; then
+    exit 0
+fi
+
+dd if=./build/image.iso of="$1"

scripts/hardware.sh

@@ -1,24 +0,0 @@
-#!/bin/bash
-
-# Colors
-GREEN='\033[0;32m'
-BLUE='\033[0;34m'
-YELLOW='\033[0;33m'
-RED='\033[0;31m'
-BOLD='\033[1m'
-NC='\033[0m' # No Color
-
-info() {
-    echo -e "${BLUE}${BOLD}info${NC}: $1"
-}
-
-warning() {
-    echo -e "${YELLOW}${BOLD}warning${NC}: $1" >&2
-}
-
-warning "This script will OVERWRITE whatever media you throw at it\nwith the built ISO."
-info "sudo ./hardware.sh /dev/yourdisk"
-
-if echo "$1" | grep -q "/dev"; then
-    dd if=./build/image.iso of="$1"
-fi

scripts/run_debug.sh

@@ -2,120 +2,16 @@
 
 # Script originally written by zxq5, I added separate scripts to remove `jq` dependency.
 
-# Colors
+script_dir=$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" &>/dev/null && pwd)
-GREEN='\033[0;32m'
+
-BLUE='\033[0;34m'
+source $script_dir/build.sh
-YELLOW='\033[0;33m'
-RED='\033[0;31m'
-BOLD='\033[1m'
-NC='\033[0m' # No Color
 
 # Error handling
 set -e
 trap 'echo -e "${RED}${BOLD}error${NC}: build failed" >&2' ERR
 
-# Get absolute path to project root
-script_dir=$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" &>/dev/null && pwd)
-project_root=$(cd "$script_dir/.." &>/dev/null && pwd)
-
 echo -e "${GREEN}${BOLD} Running kernel in debug mode."
 
-# Logging functions
-info() {
-    echo -e "${BLUE}${BOLD}info${NC}: $1"
-}
-
-compiling() {
-    echo -e "${GREEN}${BOLD}Compiling${NC}: $1"
-}
-
-warning() {
-    echo -e "${YELLOW}${BOLD}warning${NC}: $1" >&2
-}
-
-building() {
-    echo -e "${GREEN}${BOLD}Building${NC}: $1"
-}
-
-copying() {
-    echo -e "${GREEN}${BOLD}  Copying${NC}: $1 to $2"
-}
-
-error() {
-    echo -e "${RED}${BOLD}error${NC}: $1" >&2
-    exit 1
-}
-
-copy_file() {
-    copying $1 $2
-    cp "$1" "$2" || error $3
-}
-
-build_dir="$project_root/build"
-iso_root="$build_dir/iso_root"
-
-# Check if we're running tests
-is_test=0
-if [[ $1 == *"deps"* ]]; then
-    is_test=1
-    kernel_path="$1"
-else
-    # Build the kernel normally
-    cd "$project_root"
-    # cargo build
-    kernel_path="$build_dir/target/x86_64-kernel/debug/kernel"
-fi
-
-# Check for required tools
-check_tools() {
-    local missing=0
-    for tool in xorriso git qemu-system-x86_64; do
-        if ! command -v $tool >/dev/null 2>&1; then
-            error "required tool '$tool' is not installed"
-            missing=1
-        fi
-    done
-    if [ $missing -eq 1 ]; then
-        error "missing required tools"
-    fi
-}
-
-# Create build directory structure
-info "Creating build directory structure"
-mkdir -p "$iso_root/boot/limine"
-mkdir -p "$iso_root/EFI/BOOT"
-
-# Clone Limine if needed
-if [ ! -d "$build_dir/limine" ]; then
-    compiling "limine bootloader"
-    cd "$build_dir"
-    git clone https://github.com/limine-bootloader/limine.git --branch=v9.x-binary --depth=1 "$build_dir/limine" || error "failed to clone limine"
-    make -C "$build_dir/limine" || error "failed to build limine"
-    cd "$project_root"
-fi
-
-# Copy files
-info "Copying files to ISO root"
-copy_file "$kernel_path" "$iso_root/boot/kernel" "failed to copy kernel"
-copy_file "$project_root/config/limine.conf" "$iso_root/boot/limine/limine.conf" "failed to copy limine config"
-copy_file "$build_dir/limine/limine-bios-cd.bin" "$iso_root/boot/limine/" "failed to copy limine-bios-cd.bin"
-copy_file "$build_dir/limine/limine-uefi-cd.bin" "$iso_root/boot/limine/" "failed to copy limine-uefi-cd.bin"
-copy_file "$build_dir/limine/limine-bios.sys" "$iso_root/boot/limine/" "failed to copy limine-bios.sys"
-copy_file "$build_dir/limine/BOOTX64.EFI" "$iso_root/EFI/BOOT/" "failed to copy BOOTX64.EFI"
-copy_file "$build_dir/limine/BOOTIA32.EFI" "$iso_root/EFI/BOOT/" "failed to copy BOOTIA32.EFI"
-
-# Create ISO
-building "bootable ISO image"
-xorriso -as mkisofs -R -r -J -b boot/limine/limine-bios-cd.bin \
-        -no-emul-boot -boot-load-size 4 -boot-info-table -hfsplus \
-        -apm-block-size 2048 --efi-boot boot/limine/limine-uefi-cd.bin \
-        -efi-boot-part --efi-boot-image --protective-msdos-label \
-        "$iso_root" -o "$build_dir/image.iso" || error "failed to create ISO"
-
-# Install Limine
-info "Installing Limine bootloader"
-"$build_dir/limine/limine" bios-install "$build_dir/image.iso" || error "failed to install limine"
-
 # Check if KVM is available
 if [ "${KVM_FLAG:-enable}" = "disable" ]; then
     warning "KVM acceleration disabled by user"
@@ -135,6 +31,24 @@ else
     debug_flags=""
 fi
 
+# Set up test-specific flags
+if [ $is_test -eq 1 ]; then
+    test_flags="-device isa-debug-exit,iobase=0xf4,iosize=0x04 -display none"
+    serial_flags="-serial stdio"
+else
+    test_flags=""
+    # serial_flags="-serial tcp:127.0.0.1:1234,server -monitor telnet:127.0.0.1:1235,server"
+    serial_flags="-serial stdio"
+fi
+
+# Set up VM memory
+if [ $VM_MEMORY ]; then
+    vm_memory_flag="-m $VM_MEMORY"
+else
+    vm_memory_flag="-m 2G"
+fi
+
+# Set up boot flags
 if [ $USE_LEGACY_BIOS ]; then
     boot_flags=""
 else
@@ -152,16 +66,6 @@ else
                 -drive if=pflash,format=raw,file=$build_dir/RELEASEX64_OVMF_VARS.fd"
 fi
 
-# Set up test-specific flags
-if [ $is_test -eq 1 ]; then
-    test_flags="-device isa-debug-exit,iobase=0xf4,iosize=0x04 -display none"
-    serial_flags="-serial stdio"
-else
-    test_flags=""
-    # serial_flags="-serial tcp:127.0.0.1:1234,server -monitor telnet:127.0.0.1:1235,server"
-    serial_flags="-serial stdio"
-fi
-
 # Run in QEMU
 if [[ ${QEMU_FLAGS} == *-S* ]]; then
     info "Running OS in QEMU with GDB debugging enabled"
@@ -188,20 +92,14 @@ check_test_res() {
     fi
 }
 
-
-kvm_flag=""
-
 trap 'check_test_res "tests completed"' ERR
  
-    # $build_dir/image.iso
-
-
 cd "$project_root"
 qemu-system-x86_64 -M q35 \
     -cdrom "$build_dir/image.iso" \
     ${kvm_flag} \
     -boot d \
-    -m 2G \
+    ${vm_memory_flag} \
     ${serial_flags} \
     -no-reboot \
     ${test_flags} \

scripts/run_release.sh

@@ -2,120 +2,23 @@
 
 # Script originally written by zxq5, I added separate scripts to remove `jq` dependency.
 
-# Colors
+script_dir=$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" &>/dev/null && pwd)
-GREEN='\033[0;32m'
+
-BLUE='\033[0;34m'
+source $script_dir/build.sh
-YELLOW='\033[0;33m'
-RED='\033[0;31m'
-BOLD='\033[1m'
-NC='\033[0m' # No Color
 
 # Error handling
 set -e
 trap 'echo -e "${RED}${BOLD}error${NC}: build failed" >&2' ERR
 
-# Get absolute path to project root
-script_dir=$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" &>/dev/null && pwd)
-project_root=$(cd "$script_dir/.." &>/dev/null && pwd)
-
 echo -e "${GREEN}${BOLD} Running kernel in release mode."
 
-# Logging functions
-info() {
-    echo -e "${BLUE}${BOLD}info${NC}: $1"
-}
 
-compiling() {
+if [ $VM_MEMORY ]; then
-    echo -e "${GREEN}${BOLD}Compiling${NC}: $1"
+    vm_memory_flag="-m $VM_MEMORY"
-}
-
-warning() {
-    echo -e "${YELLOW}${BOLD}warning${NC}: $1" >&2
-}
-
-building() {
-    echo -e "${GREEN}${BOLD}Building${NC}: $1"
-}
-
-copying() {
-    echo -e "${GREEN}${BOLD}  Copying${NC}: $1 to $2"
-}
-
-error() {
-    echo -e "${RED}${BOLD}error${NC}: $1" >&2
-    exit 1
-}
-
-copy_file() {
-    copying $1 $2
-    cp "$1" "$2" || error $3
-}
-
-build_dir="$project_root/build"
-iso_root="$build_dir/iso_root"
-
-# Check if we're running tests
-is_test=0
-if [[ $1 == *"deps"* ]]; then
-    is_test=1
-    kernel_path="$1"
 else
-    # Build the kernel normally
+    vm_memory_flag="-m 2G"
-    cd "$project_root"
-    # cargo build
-    kernel_path="$build_dir/target/x86_64-kernel/release/kernel"
 fi
 
-# Check for required tools
-check_tools() {
-    local missing=0
-    for tool in xorriso git qemu-system-x86_64; do
-        if ! command -v $tool >/dev/null 2>&1; then
-            error "required tool '$tool' is not installed"
-            missing=1
-        fi
-    done
-    if [ $missing -eq 1 ]; then
-        error "missing required tools"
-    fi
-}
-
-# Create build directory structure
-info "Creating build directory structure"
-mkdir -p "$iso_root/boot/limine"
-mkdir -p "$iso_root/EFI/BOOT"
-
-# Clone Limine if needed
-if [ ! -d "$build_dir/limine" ]; then
-    compiling "limine bootloader"
-    cd "$build_dir"
-    git clone https://github.com/limine-bootloader/limine.git --branch=v9.x-binary --depth=1 "$build_dir/limine" || error "failed to clone limine"
-    make -C "$build_dir/limine" || error "failed to build limine"
-    cd "$project_root"
-fi
-
-# Copy files
-info "Copying files to ISO root"
-copy_file "$kernel_path" "$iso_root/boot/kernel" "failed to copy kernel"
-copy_file "$project_root/config/limine.conf" "$iso_root/boot/limine/limine.conf" "failed to copy limine config"
-copy_file "$build_dir/limine/limine-bios-cd.bin" "$iso_root/boot/limine/" "failed to copy limine-bios-cd.bin"
-copy_file "$build_dir/limine/limine-uefi-cd.bin" "$iso_root/boot/limine/" "failed to copy limine-uefi-cd.bin"
-copy_file "$build_dir/limine/limine-bios.sys" "$iso_root/boot/limine/" "failed to copy limine-bios.sys"
-copy_file "$build_dir/limine/BOOTX64.EFI" "$iso_root/EFI/BOOT/" "failed to copy BOOTX64.EFI"
-copy_file "$build_dir/limine/BOOTIA32.EFI" "$iso_root/EFI/BOOT/" "failed to copy BOOTIA32.EFI"
-
-# Create ISO
-building "bootable ISO image"
-xorriso -as mkisofs -R -r -J -b boot/limine/limine-bios-cd.bin \
-        -no-emul-boot -boot-load-size 4 -boot-info-table -hfsplus \
-        -apm-block-size 2048 --efi-boot boot/limine/limine-uefi-cd.bin \
-        -efi-boot-part --efi-boot-image --protective-msdos-label \
-        "$iso_root" -o "$build_dir/image.iso" || error "failed to create ISO"
-
-# Install Limine
-info "Installing Limine bootloader"
-"$build_dir/limine/limine" bios-install "$build_dir/image.iso" || error "failed to install limine"
-
 # Check if KVM is available
 if [ "${KVM_FLAG:-enable}" = "disable" ]; then
     warning "KVM acceleration disabled by user"
@@ -128,9 +31,6 @@ else
     kvm_flag=""
 fi
 
-# I'm lazy but I just remove GDB flags when running this script.
-debug_flags=""
-
 if [ $USE_LEGACY_BIOS ]; then
     boot_flags=""
 else
@@ -148,56 +48,13 @@ else
                 -drive if=pflash,format=raw,file=$build_dir/RELEASEX64_OVMF_VARS.fd"
 fi
 
-# Set up test-specific flags
-if [ $is_test -eq 1 ]; then
-    test_flags="-device isa-debug-exit,iobase=0xf4,iosize=0x04 -display none"
-    serial_flags="-serial stdio"
-else
-    test_flags=""
-    # serial_flags="-serial tcp:127.0.0.1:1234,server -monitor telnet:127.0.0.1:1235,server"
-    serial_flags="-serial stdio"
-fi
-
-# Run in QEMU
-if [[ ${QEMU_FLAGS} == *-S* ]]; then
-    info "Running OS in QEMU with GDB debugging enabled"
-    info "To connect GDB, run: gdb"
-    info "At the GDB prompt, type: target remote localhost:1234"
-else
-    info "Running OS in QEMU..."
-fi
-
-check_test_res() {
-    qemu_exit_code=$?
-    if [ $qemu_exit_code -eq 33 ]; then
-        # Success case (0x10 << 1) | 1 = 33
-        info "All tests passed"
-        exit 0
-    elif [ $qemu_exit_code -eq 35 ]; then
-        # Failure case (0x11 << 1) | 1 = 35
-        warning "Some tests failed"
-        exit 1
-    else
-        # Any other exit code is treated as a failure
-        warning "Some tests failed"
-        exit 1
-    fi
-}
-
-
-kvm_flag=""
-
-trap 'check_test_res "tests completed"' ERR
- 
 cd "$project_root"
 qemu-system-x86_64 -M q35 \
     ${kvm_flag} \
     -cdrom "$build_dir/image.iso" \
     -boot d \
-    -m 2G \
+    ${vm_memory_flag} \
     ${serial_flags} \
     -no-reboot \
-    ${test_flags} \
+    ${boot_flags}
-    ${debug_flags} \
-    ${QEMU_FLAGS:-}