Megacommit to move some memory code into kernel crate

@zxq5 thoughts?

Cargo.lock

@@ -64,6 +64,47 @@ version = "0.8.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
 
+[[package]]
+name = "darling"
+version = "0.20.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f63b86c8a8826a49b8c21f08a2d07338eec8d900540f8630dc76284be802989"
+dependencies = [
+ "darling_core",
+ "darling_macro",
+]
+
+[[package]]
+name = "darling_core"
+version = "0.20.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "95133861a8032aaea082871032f5815eb9e98cef03fa916ab4500513994df9e5"
+dependencies = [
+ "fnv",
+ "ident_case",
+ "proc-macro2",
+ "quote",
+ "strsim",
+ "syn",
+]
+
+[[package]]
+name = "darling_macro"
+version = "0.20.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d336a2a514f6ccccaa3e09b02d41d35330c07ddf03a62165fcec10bb561c7806"
+dependencies = [
+ "darling_core",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "fnv"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
+
 [[package]]
 name = "foundry_os"
 version = "0.1.0"
@@ -101,12 +142,19 @@ dependencies = [
  "pin-utils",
 ]
 
+[[package]]
+name = "ident_case"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
+
 [[package]]
 name = "libk"
 version = "0.1.0"
 dependencies = [
  "crossbeam",
  "futures-util",
+ "libm",
  "limine",
  "linked_list_allocator",
  "pc-keyboard",
@@ -114,6 +162,16 @@ dependencies = [
  "x86_64",
 ]
 
+[[package]]
+name = "libm"
+version = "0.1.0"
+dependencies = [
+ "darling",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "limine"
 version = "0.3.1"
@@ -169,6 +227,24 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
 
+[[package]]
+name = "proc-macro2"
+version = "1.0.93"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60946a68e5f9d28b0dc1c21bb8a97ee7d018a8b322fa57838ba31cc878e22d99"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.38"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0e4dccaaaf89514f546c693ddc140f729f958c247918a13380cccc6078391acc"
+dependencies = [
+ "proc-macro2",
+]
+
 [[package]]
 name = "rustversion"
 version = "1.0.19"
@@ -205,6 +281,29 @@ dependencies = [
  "lock_api",
 ]
 
+[[package]]
+name = "strsim"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
+
+[[package]]
+name = "syn"
+version = "2.0.98"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "36147f1a48ae0ec2b5b3bc5b537d267457555a10dc06f3dbc8cb11ba3006d3b1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "00e2473a93778eb0bad35909dff6a10d28e63f792f16ed15e404fca9d5eeedbe"
+
 [[package]]
 name = "volatile"
 version = "0.4.6"

Cargo.toml

@@ -1,5 +1,5 @@
 [workspace]
-members = ["kernel", "libk"]
+members = ["kernel", "libk", "libm"]
 resolver = "2"
 
 [workspace.package]

README.md

@@ -1,24 +1,52 @@
 # FoundryOS
 
-## Cloning and building
-
-Here are some simple steps to get started:
-
+## Cloning
 ```sh
 git clone https://git.zxq5.dev/OsDev/FoundryOS.git
+```
+
+## Build dependencies
+
+* latest rust nightly release
+* all necessary rust components installed
+* xorriso: creates ISO images to be booted from.
+* (Optional / Recommended) qemu: to run the kernel. (this may be packaged as qemu-desktop)
+* (Optional) GDB: for debugging the kernel.
+
+```sh
+rustup update
+rustup override set nightly
+rustup component add rust-src
+rustup component add llvm-tools-preview
+```
+
+## Building & Running in qemu
+```sh
 cargo run
 ```
 
-## Running in GDB:
+## Running in GDB
 ```sh
 USE_GDB=1 cargo run
 ```
 
-### Build dependencies
+## Build errors
 
-* libisoburn: creates ISO images to be booted from.
-* qemu: to run the kernel.
+If you see a qemu error like this:
 
-Optionally,
+```
+qemu-system-x86_64: -drive if=pflash,format=raw,readonly=on,file=<...>/OVMF_CODE.fd: Could not open '<...>/OVMF_CODE.fd': No such file or directory
+```
 
-* GDB: for debugging the kernel.
+Simply delete the ./build directory and try to rebuild the program. Using the runner script or `cargo run` will download the required files for you, this is because the script only checks for the presence of one file and not the VARS file.
+
+Alternatively, you may disable using a UEFI firmware with qemu like so:
+```sh
+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.

config/limine.conf

@@ -1,5 +1,5 @@
 # Timeout in seconds that Limine will use before automatically booting.
-timeout: 1
+timeout: 0
 
 # The entry name that will be displayed in the boot menu.
 /foundry-os

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/workspace.json

@@ -189,7 +189,7 @@
       "command-palette:Open command palette": false
     }
   },
-  "active": "e1fb15cab546d0b6",
+  "active": "add883d295e04659",
   "lastOpenFiles": [
     "Usage",
     "Welcome.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/Usage/Building The Kernel.md

@@ -1,4 +1,4 @@
-# Usage 
+#usage 
 ### Requirements
 - Latest rust nightly release
 > rustup update

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

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

kernel/src/arch/x86_64/interrupts.rs

@@ -1,8 +1,8 @@
+// use libk::drivers::mem::{FRAME_ALLOCATOR, OFFSET_PAGE_TABLE};
 use libk::prelude::*;
-use x86_64::registers::control::Cr2;
+use pic8259::ChainedPics;
 use x86_64::structures::idt::{InterruptDescriptorTable, InterruptStackFrame, PageFaultErrorCode};
 
-use pic8259::ChainedPics;
 use spin::{Lazy, Mutex};
 
 use super::gdt;
@@ -40,7 +40,7 @@ pub enum InterruptIndex {
 }
 
 impl InterruptIndex {
-    fn as_u8(self) -> u8 {
+    const fn as_u8(self) -> u8 {
         self as u8
     }
 
@@ -51,12 +51,22 @@ impl InterruptIndex {
 
 pub fn init_idt() {
     IDT.load();
+}
+
+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);
@@ -79,7 +89,7 @@ extern "x86-interrupt" fn double_fault_handler(
 }
 
 extern "x86-interrupt" fn keyboard_interrupt_handler(_stack_frame: InterruptStackFrame) {
-    use pc_keyboard::{layouts, HandleControl, Keyboard, ScancodeSet1};
+    use pc_keyboard::{HandleControl, Keyboard, ScancodeSet1, layouts};
     // use pc_keyboard::DecodedKey;
     use spin::Mutex;
     use x86_64::instructions::port::Port;
@@ -96,7 +106,7 @@ extern "x86-interrupt" fn keyboard_interrupt_handler(_stack_frame: InterruptStac
     let mut port = Port::new(0x60);
 
     let scancode: u8 = unsafe { port.read() };
-    libk::io::keyboard::add_scancode(scancode);
+    libk::drivers::io::keyboard::add_scancode(scancode);
 
     unsafe {
         PICS.lock()
@@ -112,13 +122,32 @@ extern "x86-interrupt" fn timer_interrupt_handler(_stack_frame: InterruptStackFr
 }
 
 extern "x86-interrupt" fn page_fault_handler(
-    stack_frame: InterruptStackFrame,
-    error_code: PageFaultErrorCode,
+    _stack_frame: InterruptStackFrame,
+    _error_code: PageFaultErrorCode,
 ) {
-    serial_println!("Exception: Page Fault");
-    serial_println!("Accessed Address: {:?}", Cr2::read());
-    serial_println!("Error Code: {:?}", error_code);
-    serial_println!("{:#?}", stack_frame);
+    todo!("Get this working again.")
+    // serial_println!("Exception: Page Fault");
+    // serial_println!("Accessed Address: {:?}", Cr2::read());
+    // 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;
@@ -48,9 +48,8 @@ pub static _KERNEL_PHYSICAL_MEMORY_OFFSET: Lazy<(u64, u64)> = Lazy::new(|| {
 ///
 /// Panics if the memory map was not found in MEMORY_MAP_REQUEST.
 pub fn get_memory_map() -> &'static MemoryMapResponse {
-    if let Some(memory_map) = MEMORY_MAP_REQUEST.get_response() {
-        memory_map
-    } else {
-        unreachable!("Could not fetch memory map from Limine.")
-    }
+    MEMORY_MAP_REQUEST.get_response().map_or_else(
+        || unreachable!("Could not fetch memory map from Limine."),
+        |memory_map| memory_map,
+    )
 }

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(crate) 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 unsafe fn init(memory_map: &'static MemoryMapResponse) -> FoundryOSFrameAllocator {
-        FoundryOSFrameAllocator {
-            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 memory;
-
-pub(crate) mod memmap;
+pub mod mem;

kernel/src/lib.rs

@@ -1,16 +1,26 @@
 #![no_std]
 #![feature(abi_x86_interrupt)]
+#![warn(
+    clippy::correctness,
+    clippy::nursery,
+    clippy::unnecessary_cast,
+    clippy::all,
+    clippy::suspicious,
+    clippy::perf,
+    rustdoc::missing_errors_doc,
+    rustdoc::missing_panics_doc
+)]
 
 extern crate alloc;
 
+// use arch::x86_64::apic::enable_apic;
 use core::arch::asm;
+// use libk::drivers::mem::pmm;
 use limine::BaseRevision;
 
-use libk::alloc::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.
@@ -46,13 +56,16 @@ 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... ");
-    libk::io::serial::init()?;
-    println_log!("[Success]");
+    if libk::drivers::io::serial::init().is_err() {
+        println_log!("[Not Detected]")
+    } else {
+        println_log!("[Success]");
+    }
 
     print_log!("    Setting Up Global Descriptor Table... ");
     gdt::init();
@@ -62,21 +75,34 @@ pub fn boot() -> Result<(), &'static str> {
     interrupts::init_idt();
     println_log!("[Success]");
 
-    print_log!("    Setting Up Page Table... ");
-    let mut frame_allocator = unsafe { memory::FoundryOSFrameAllocator::init(memory_map) };
+    print_log!("    Initialising Memory Subsystem... ");
+    // 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... ");
-    let physical_memory_offset = VirtAddr::new(*memmap::PHYSICAL_MEMORY_OFFSET);
-    let mut l4_table = unsafe { memory::init(physical_memory_offset) };
+    print_log!("    Setting Up Page Table... ");
+    // pmm::init_frame_allocator(memory_map);
     println_log!("[Success]");
 
     print_log!("    Initialising Heap... ");
-    if init_heap(&mut l4_table, &mut frame_allocator).is_err() {
-        return Err("Failed to initialise heap: error");
-    }
+    // TODO: Reenable the heap.
+    // 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

@@ -4,9 +4,12 @@
 extern crate alloc;
 
 use libk::{
-    io,
+    drivers::{
+        async_io::task::{Executor, Task},
+        io,
+    },
     prelude::*,
-    scheduling::task::{Executor, Task},
+    util::shell::shell,
 };
 
 #[unsafe(no_mangle)]
@@ -19,35 +22,19 @@ extern "C" fn kmain() -> ! {
     println_log!("[ Kernel Initialised Successfully ] ");
 
     let dimensions = io::ascii::screensize_chars();
-    let dimensions2 = io::ascii::screensize_px();
+    let dimensions2 = io::framebuffer::display::screensize_px();
 
     println!("Dimensions: {}x{} (px)", dimensions2.0, dimensions2.1);
     println!("Dimensions: {}x{} (chars)", dimensions.0, dimensions.1);
 
-    println!(
-        "
-        $$$$$$$$\\                                  $$\\                     
-        $$  _____|                                 $$ |                    
-        $$ |    $$$$$$\\  $$\\   $$\\ $$$$$$$\\   $$$$$$$ | $$$$$$\\  $$\\   $$\\ 
-        $$$$$\\ $$  __$$\\ $$ |  $$ |$$  __$$\\ $$  __$$ |$$  __$$\\ $$ |  $$ |
-        $$  __|$$ /  $$ |$$ |  $$ |$$ |  $$ |$$ /  $$ |$$ |  \\__|$$ |  $$ |
-        $$ |   $$ |  $$ |$$ |  $$ |$$ |  $$ |$$ |  $$ |$$ |      $$ |  $$ |
-        $$ |   \\$$$$$$  |\\$$$$$$  |$$ |  $$ |\\$$$$$$$ |$$ |      \\$$$$$$$ |
-        \\__|    \\______/  \\______/ \\__|  \\__| \\_______|\\__|       \\____$$ |
-             $$$$$$\\   $$$$$$\\        $$\\    $$\\   $$\\           $$\\   $$ |
-            $$  __$$\\ $$  __$$\\       $$ |   $$ |$$$$ |          \\$$$$$$  |
-            $$ /  $$ |$$ /  \\__|      $$ |   $$ |\\_$$ |           \\______/ 
-            $$ |  $$ |\\$$$$$$\\        \\$$\\  $$  |  $$ |                  
-            $$ |  $$ | \\____$$\\        \\$$\\$$  /   $$ |                  
-            $$ |  $$ |$$\\   $$ |        \\$$$  /    $$ |                  
-             $$$$$$  |\\$$$$$$  |         \\$  /   $$$$$$\\                 
-             \\______/  \\______/           \\_/    \\______|                              
-    "
-    );
-
     let mut executor = Executor::new();
-    executor.spawn(Task::new(io::keyboard::print_keypresses()));
-    executor.try_run();
 
-    loop {}
+    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/Cargo.toml

@@ -19,3 +19,4 @@ futures-util = { version = "0.3.31", default-features = false, features = [
     "alloc",
 ] }
 linked_list_allocator = "0.10.5"
+libm = { path = "../libm" }

libk/src/alloc.rs

@@ -1,3 +0,0 @@
-pub mod allocator;
-
-pub use self::allocator::init_heap;

libk/src/alloc/allocator.rs

@@ -1,45 +0,0 @@
-use linked_list_allocator::LockedHeap;
-use x86_64::{
-    structures::paging::{
-        mapper::MapToError, FrameAllocator, Mapper, Page, PageTableFlags, Size4KiB,
-    },
-    VirtAddr,
-};
-
-/// 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/async_io/task.rs

@@ -1,12 +1,20 @@
-extern crate alloc;
-use alloc::{boxed::Box, collections::BTreeMap, sync::Arc, task::Wake};
+//! Allows creation of asynchronous IO bound tasks.
+//!
+//! Written by @zxq5 for the most part with code from
+//! [here](https://github.com/phil-opp/blog_os/).
+//!
+use crate::prelude::*;
+use alloc::collections::BTreeMap;
+use alloc::sync::Arc;
+use alloc::task::Wake;
 use core::{
     future::Future,
     pin::Pin,
-    sync::atomic::{AtomicU64, Ordering},
+    sync::atomic::AtomicU64,
     task::{Context, Poll, Waker},
 };
 use crossbeam::queue::ArrayQueue;
+use x86_64::instructions::interrupts::{self, enable_and_hlt};
 
 pub struct Task {
     id: TaskId,
@@ -26,18 +34,22 @@ impl Task {
     }
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+struct TaskId(u64);
+
+impl TaskId {
+    fn new() -> Self {
+        static NEXT: AtomicU64 = AtomicU64::new(0);
+        Self(NEXT.fetch_add(1, core::sync::atomic::Ordering::Relaxed))
+    }
+}
+
 pub struct Executor {
     tasks: BTreeMap<TaskId, Task>,
     task_queue: Arc<ArrayQueue<TaskId>>,
     waker_cache: BTreeMap<TaskId, Waker>,
 }
 
-impl Default for Executor {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
 impl Executor {
     pub fn new() -> Self {
         Self {
@@ -50,12 +62,13 @@ impl Executor {
     pub fn spawn(&mut self, task: Task) {
         let task_id = task.id;
         if self.tasks.insert(task.id, task).is_some() {
-            panic!("a task with this id has already been allocated");
+            panic!("task with same id already in tasks");
         }
-        self.task_queue.push(task_id).expect("task queue is full");
+        self.task_queue.push(task_id).expect("queue full");
     }
 
     fn run_ready_tasks(&mut self) {
+        // destructure `self` to avoid borrow checker errors
         let Self {
             tasks,
             task_queue,
@@ -65,14 +78,15 @@ impl Executor {
         while let Some(task_id) = task_queue.pop() {
             let task = match tasks.get_mut(&task_id) {
                 Some(task) => task,
-                None => continue,
+                None => continue, // task no longer exists
             };
             let waker = waker_cache
                 .entry(task_id)
-                .or_insert_with(|| TaskWaker::waker(task_id, task_queue.clone()));
+                .or_insert_with(|| TaskWaker::new_waker(task_id, task_queue.clone()));
             let mut context = Context::from_waker(waker);
             match task.poll(&mut context) {
                 Poll::Ready(()) => {
+                    // task done -> remove it and its cached waker
                     tasks.remove(&task_id);
                     waker_cache.remove(&task_id);
                 }
@@ -81,14 +95,14 @@ impl Executor {
         }
     }
 
-    pub fn try_run(&mut self) {
-        self.run_ready_tasks();
-        self.sleep_if_idle();
+    pub fn run(&mut self) -> ! {
+        loop {
+            self.run_ready_tasks();
+            self.sleep_if_idle();
+        }
     }
 
     fn sleep_if_idle(&self) {
-        use x86_64::instructions::interrupts::{self, enable_and_hlt};
-
         interrupts::disable();
         if self.task_queue.is_empty() {
             enable_and_hlt();
@@ -98,24 +112,28 @@ impl Executor {
     }
 }
 
+impl Default for Executor {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 struct TaskWaker {
     task_id: TaskId,
     task_queue: Arc<ArrayQueue<TaskId>>,
 }
 
 impl TaskWaker {
-    fn waker(task_id: TaskId, task_queue: Arc<ArrayQueue<TaskId>>) -> Waker {
+    fn wake_task(&self) {
+        self.task_queue.push(self.task_id).expect("task_queue full");
+    }
+
+    fn new_waker(task_id: TaskId, task_queue: Arc<ArrayQueue<TaskId>>) -> Waker {
         Waker::from(Arc::new(Self {
             task_id,
             task_queue,
         }))
     }
-
-    fn wake_task(&self) {
-        self.task_queue
-            .push(self.task_id)
-            .expect("task queue is full!");
-    }
 }
 
 impl Wake for TaskWaker {
@@ -127,13 +145,3 @@ impl Wake for TaskWaker {
         self.wake_task();
     }
 }
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
-struct TaskId(u64);
-
-impl TaskId {
-    fn new() -> Self {
-        static NEXT: AtomicU64 = AtomicU64::new(0);
-        Self(NEXT.fetch_add(1, Ordering::Relaxed))
-    }
-}

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

@@ -2,11 +2,9 @@ use core::fmt;
 use spin::{Lazy, Mutex};
 use x86_64::instructions::interrupts;
 
-pub use super::framebuffer::screensize_px;
-use super::framebuffer::{Colour, FRAMEBUFFER_WRITER};
+use super::framebuffer::{colour::Colour, display::FRAMEBUFFER_WRITER};
 
-mod font;
-use font::FONT;
+use crate::resources::font::{FONT_SPLEEN_8X16, Font};
 
 static FONT_WIDTH: u32 = 8;
 static FONT_HEIGHT: u32 = 16;
@@ -19,6 +17,7 @@ pub fn screensize_chars() -> (u32, u32) {
 }
 
 pub struct Writer {
+    font: &'static Font,
     /// Measured in chars not pixels.
     screen_width: u32,
     /// Measured in chars not pixels.
@@ -30,9 +29,6 @@ pub struct Writer {
 
     fg_color: Colour,
     bg_color: Colour,
-
-    offset1: usize,
-    offset2: usize,
 }
 
 impl Default for Writer {
@@ -48,26 +44,35 @@ impl Writer {
                 panic!("Framebuffer writer not initialized.");
             },
             |writer| Self {
+                font: &FONT_SPLEEN_8X16,
                 screen_width: writer.width() / 8,
                 screen_height: writer.height() / 16,
                 text_line: 0,
                 text_col: 0,
                 fg_color: Colour::White,
                 bg_color: Colour::Black,
-                offset1: 16,
-                offset2: 0,
             },
         )
     }
 
-    pub fn write_glyph(&mut self, c: u16) {
-        if c as u8 == b'\n' {
+    pub const fn set_font(&mut self, font: &'static Font) {
+        self.font = font;
+    }
+
+    /// This is sent when the user types a backspace.
+    const BACKSPACE: u8 = 8;
+
+    pub fn write_glyph(&mut self, c: u8) {
+        if c == b'\n' {
             self.newline();
             return;
+        } else if c == Self::BACKSPACE {
+            self.backspace();
+            return;
         }
 
-        // get the character data from the font array. -- each byte is a row of pixels
-        let data: &[u8] = &FONT[c as usize * 16..(c as usize + 1) * 16];
+        // Get the character data from the font array. -- each byte is a row of pixels
+        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) {
@@ -76,17 +81,17 @@ impl Writer {
                     let pixel_y: u32 = self.text_line * FONT_HEIGHT + row as u32;
 
                     if line & (0x80 >> col) != 0 {
-                        // write the foreground color
+                        // Write the foreground color
                         writer.write_pixel(pixel_x as usize, pixel_y as usize, self.fg_color);
                     } else {
-                        // write the background color
+                        // Write the background color
                         writer.write_pixel(pixel_x as usize, pixel_y as usize, self.bg_color);
                     }
                 }
             }
         }
 
-        // go to next position
+        // Go to next position
         if self.text_col + 1 >= self.screen_width {
             self.newline();
         } else {
@@ -94,11 +99,6 @@ impl Writer {
         }
     }
 
-    pub const fn set_offset(&mut self, offset1: usize, offset2: usize) {
-        self.offset1 = offset1;
-        self.offset2 = offset2;
-    }
-
     pub const fn dimensions(&self) -> (u32, u32) {
         (self.screen_width, self.screen_height)
     }
@@ -117,9 +117,20 @@ impl Writer {
         }
     }
 
+    /// Handles the backspace character. TODO: Implement VT-100 style terminal control
+    /// codes alongside a shell. Not simple.
+    pub fn backspace(&mut self) {
+        if self.text_col > 0 {
+            self.text_col -= 1;
+            // Blank out the previous char.
+            self.write_glyph(b' ');
+            self.text_col -= 1;
+        }
+    }
+
     pub fn write_string(&mut self, s: &str) {
         for c in s.chars() {
-            self.write_glyph(c as u16);
+            self.write_glyph(c as u8);
         }
     }
 
@@ -182,6 +193,14 @@ pub fn clear_screen() {
     });
 }
 
+pub fn reset_cursor() {
+    interrupts::without_interrupts(|| {
+        let mut writer = WRITER.lock();
+        writer.text_line = 0;
+        writer.text_col = 0;
+    });
+}
+
 #[macro_export]
 macro_rules! println_log {
 	() => ($crate::print_log!("\n"));
@@ -190,7 +209,7 @@ macro_rules! println_log {
 
 #[macro_export]
 macro_rules! print_log {
-	($($arg:tt)*) => ($crate::io::ascii::_print_log(format_args!($($arg)*)));
+	($($arg:tt)*) => ($crate::_print_log(format_args!($($arg)*)));
 }
 
 #[macro_export]
@@ -201,7 +220,7 @@ macro_rules! println {
 
 #[macro_export]
 macro_rules! print {
-	($($arg:tt)*) => ($crate::io::ascii::_print(format_args!($($arg)*)));
+	($($arg:tt)*) => ($crate::_print(format_args!($($arg)*)));
 }
 
 #[macro_export]

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

@@ -4,9 +4,7 @@ use limine::request::FramebufferRequest;
 #[unsafe(link_section = ".requests")]
 static FRAMEBUFFER_REQUEST: FramebufferRequest = FramebufferRequest::new();
 
-mod colour;
-
-pub use colour::Colour;
+use super::colour::Colour;
 use core::panic;
 
 use limine::framebuffer::Framebuffer;

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

@@ -0,0 +1,2 @@
+pub mod colour;
+pub mod display;

libk/src/drivers/io/keyboard.rs

@@ -0,0 +1,206 @@
+use core::{
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+use crossbeam::queue::ArrayQueue;
+use futures_util::{Stream, StreamExt, task::AtomicWaker};
+use pc_keyboard::{
+    DecodedKey, HandleControl, KeyCode, Keyboard, ScancodeSet1,
+    layouts::{self, Uk105Key},
+};
+use spin::{Lazy, Mutex, Once};
+
+use crate::prelude::*;
+
+static KBD_QUEUE: Once<ArrayQueue<u8>> = Once::new();
+static WAKER: AtomicWaker = AtomicWaker::new();
+
+pub static KEYBOARD: Lazy<Mutex<Keyboard<Uk105Key, ScancodeSet1>>> = Lazy::new(|| {
+    Mutex::new(Keyboard::new(
+        ScancodeSet1::new(),
+        // TODO: Expose an API to change the default KB layout.
+        layouts::Uk105Key,
+        HandleControl::Ignore,
+    ))
+});
+pub static SCANCODE_STREAM: Lazy<Mutex<ScancodeStream>> =
+    Lazy::new(|| Mutex::new(ScancodeStream::new()));
+
+pub fn add_scancode(scancode: u8) {
+    if let Some(queue) = KBD_QUEUE.get() {
+        if queue.push(scancode).is_err() {
+            println!("WARNING: scancode queue full; dropping keyboard input");
+        } else {
+            WAKER.wake();
+        }
+    } else {
+        println!("WARNING: scancode queue not initialized");
+    }
+}
+
+pub struct ScancodeStream {
+    _private: (),
+}
+
+impl ScancodeStream {
+    pub fn new() -> Self {
+        KBD_QUEUE.call_once(|| ArrayQueue::new(5));
+        Self { _private: () }
+    }
+
+    pub fn try_next(&mut self) -> Option<u8> {
+        KBD_QUEUE.get().and_then(|queue| queue.pop())
+    }
+}
+
+impl Default for ScancodeStream {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Stream for ScancodeStream {
+    type Item = u8;
+
+    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        let queue = KBD_QUEUE.get().unwrap();
+
+        if let Some(scancode) = queue.pop() {
+            return Poll::Ready(Some(scancode));
+        }
+
+        WAKER.register(cx.waker());
+        WAKER.register(cx.waker());
+
+        queue.pop().map_or(Poll::Pending, |scancode| {
+            WAKER.take();
+            Poll::Ready(Some(scancode))
+        })
+    }
+}
+
+pub async fn get_keystroke_async() -> KeyStroke {
+    loop {
+        if let Some(scancode) = SCANCODE_STREAM.lock().next().await {
+            if let Ok(keystroke) = KeyStroke::try_from(scancode) {
+                return keystroke;
+            }
+        }
+    }
+}
+
+pub fn get_keystroke_optional() -> Option<KeyStroke> {
+    if let Some(scancode) = SCANCODE_STREAM.lock().try_next() {
+        if let Ok(keystroke) = KeyStroke::try_from(scancode) {
+            return Some(keystroke);
+        }
+    }
+    None
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum KeyStroke {
+    Char(char),
+    Ctrl,
+    RCtrl,
+    Alt,
+    RAlt,
+    Shift,
+    RShift,
+    Meta,
+    RMeta,
+    Backspace,
+    Left,
+    Right,
+    Up,
+    Down,
+    None,
+    Enter,
+    Escape,
+    Del,
+}
+
+impl KeyStroke {
+    pub const fn from_keycode(key: KeyCode) -> Self {
+        match key {
+            KeyCode::LControl => Self::Ctrl,
+            KeyCode::RControl => Self::RCtrl,
+            KeyCode::LAlt => Self::Alt,
+            KeyCode::RAlt2 => Self::RAlt,
+            KeyCode::LShift => Self::Shift,
+            KeyCode::RShift => Self::RShift,
+            KeyCode::LWin => Self::Meta,
+            KeyCode::RWin => Self::RMeta,
+            KeyCode::Backspace => Self::Backspace,
+            KeyCode::ArrowLeft => Self::Left,
+            KeyCode::ArrowRight => Self::Right,
+            KeyCode::ArrowUp => Self::Up,
+            KeyCode::ArrowDown => Self::Down,
+            KeyCode::Return => Self::Enter,
+            KeyCode::Escape => Self::Escape,
+            KeyCode::Delete => Self::Del,
+            _ => Self::None,
+        }
+    }
+}
+
+impl TryFrom<u8> for KeyStroke {
+    type Error = ();
+
+    fn try_from(code: u8) -> Result<Self, Self::Error> {
+        let mut keyboard = KEYBOARD.lock();
+
+        let key = match keyboard.add_byte(code) {
+            Ok(Some(event)) => match keyboard.process_keyevent(event) {
+                Some(key) => key,
+                _ => return Err(()),
+            },
+            _ => return Err(()),
+        };
+
+        match key {
+            DecodedKey::Unicode(ch) => Ok(Self::Char(ch)),
+            DecodedKey::RawKey(key) => match Self::from_keycode(key) {
+                Self::None => Err(()),
+                key => Ok(key),
+            },
+        }
+    }
+}
+
+impl TryInto<char> for KeyStroke {
+    type Error = ();
+
+    fn try_into(self) -> Result<char, Self::Error> {
+        match self {
+            Self::Char(c) => Ok(c),
+            _ => Err(()),
+        }
+    }
+}
+
+impl core::fmt::Display for KeyStroke {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Self::Char(c) => write!(f, "{}", c),
+            Self::Ctrl => write!(f, "CTRL"),
+            Self::RCtrl => write!(f, "RCtrl"),
+            Self::Alt => write!(f, "ALT"),
+            Self::RAlt => write!(f, "RAlt"),
+            Self::Shift => write!(f, "SHIFT"),
+            Self::RShift => write!(f, "RShift"),
+            Self::Meta => write!(f, "META"),
+            Self::RMeta => write!(f, "RMeta"),
+            Self::Backspace => write!(f, "BACKSPACE"),
+            Self::Left => write!(f, "LEFT"),
+            Self::Right => write!(f, "RIGHT"),
+            Self::Up => write!(f, "UP"),
+            Self::Down => write!(f, "DOWN"),
+            Self::Enter => write!(f, "ENTER"),
+            Self::Escape => write!(f, "ESCAPE"),
+            Self::None => write!(f, "NONE"),
+            Self::Del => write!(f, "DEL"),
+        }
+    }
+}

libk/src/drivers/io/serial.rs

@@ -5,14 +5,14 @@ use core::{
 use spin::{Lazy, Mutex};
 
 #[macro_export]
-macro_rules! serial_println {
-    () => ($crate::serial_print!("\n"));
-    ($($arg:tt)*) => ($crate::io::serial_print!("{}\n", format_args!($($arg)*)));
+macro_rules! serial_print {
+    ($($arg:tt)*) => ($crate::_serial_write(format_args!($($arg)*)));
 }
 
 #[macro_export]
-macro_rules! serial_print {
-    ($($arg:tt)*) => ($crate::io::serial::_serial_write(format_args!($($arg)*)));
+macro_rules! serial_println {
+    () => ($crate::serial_print!("\n"));
+    ($($arg:tt)*) => (serial_print!("{}\n", format_args!($($arg)*)));
 }
 
 use super::port::{inb, outb};

libk/src/drivers/mod.rs

@@ -0,0 +1,3 @@
+pub mod async_io;
+pub mod io;
+pub mod pic;

libk/src/drivers/pic.rs

@@ -0,0 +1,146 @@
+use x86_64::instructions::port::Port;
+
+const CMD_INIT: u8 = 0x11;
+const CMD_END_OF_INT: u8 = 0x20;
+const MODE_8086: u8 = 0x01;
+
+struct Pic {
+    offset: u8,
+    data: Port<u8>,
+    command: Port<u8>,
+}
+
+impl Pic {
+    /// Are we in charge of handling the specified interrupt?
+    /// (Each PIC handles 8 interrupts.)
+    const fn handles_interrupt(&self, interrupt_id: u8) -> bool {
+        self.offset <= interrupt_id && interrupt_id < self.offset + 8
+    }
+
+    /// Notify us that an interrupt has been handled and that we're ready
+    /// for more.
+    unsafe fn end_of_interrupt(&mut self) {
+        unsafe { self.command.write(CMD_END_OF_INT) };
+    }
+
+    /// Reads the interrupt mask of this PIC.
+    unsafe fn read_mask(&mut self) -> u8 {
+        unsafe { self.data.read() }
+    }
+
+    /// Writes the interrupt mask of this PIC.
+    unsafe fn write_mask(&mut self, mask: u8) {
+        unsafe { self.data.write(mask) }
+    }
+}
+
+/// A pair of chained PICs.  This is the standard setup on x86.
+pub struct ChainedPics {
+    pics: [Pic; 2],
+}
+
+impl ChainedPics {
+    pub const fn new(offset1: u8, offset2: u8) -> Self {
+        Self {
+            pics: [
+                Pic {
+                    offset: offset1,
+                    command: Port::new(0x20),
+                    data: Port::new(0x21),
+                },
+                Pic {
+                    offset: offset2,
+                    command: Port::new(0xA0),
+                    data: Port::new(0xA1),
+                },
+            ],
+        }
+    }
+
+    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 unsafe fn initialize(&mut self) {
+        unsafe {
+            let mut wait_port: Port<u8> = Port::new(0x80);
+            let mut wait = || wait_port.write(0);
+
+            // Save our original interrupt masks, because I'm too lazy to
+            // figure out reasonable values. We'll restore these when we're
+            // done.
+            let saved_masks = self.read_masks();
+
+            // Tell each PIC that we're going to send it a three-byte
+            // initialization sequence on its data port.
+            self.pics[0].command.write(CMD_INIT);
+            wait();
+            self.pics[1].command.write(CMD_INIT);
+            wait();
+
+            // Byte 1: Set up our base offsets.
+            self.pics[0].data.write(self.pics[0].offset);
+            wait();
+            self.pics[1].data.write(self.pics[1].offset);
+            wait();
+
+            // Byte 2: Configure chaining between PIC1 and PIC2.
+            self.pics[0].data.write(4);
+            wait();
+            self.pics[1].data.write(2);
+            wait();
+
+            // Byte 3: Set our mode.
+            self.pics[0].data.write(MODE_8086);
+            wait();
+            self.pics[1].data.write(MODE_8086);
+            wait();
+
+            // Restore our saved masks.
+            self.write_masks(saved_masks[0], saved_masks[1])
+        }
+    }
+
+    /// Reads the interrupt masks of both PICs.
+    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 fn write_masks(&mut self, mask1: u8, mask2: u8) {
+        unsafe {
+            self.pics[0].write_mask(mask1);
+            self.pics[1].write_mask(mask2);
+        }
+    }
+
+    /// Disables both PICs by masking all interrupts.
+    pub fn disable(&mut self) {
+        self.write_masks(u8::MAX, u8::MAX)
+    }
+
+    /// Do we handle this interrupt?
+    pub fn handles_interrupt(&self, interrupt_id: u8) -> bool {
+        self.pics.iter().any(|p| p.handles_interrupt(interrupt_id))
+    }
+
+    /// 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) {
+        if self.handles_interrupt(interrupt_id) {
+            if self.pics[1].handles_interrupt(interrupt_id) {
+                unsafe {
+                    self.pics[1].end_of_interrupt();
+                }
+            }
+            unsafe {
+                self.pics[0].end_of_interrupt();
+            }
+        }
+    }
+}

libk/src/io/keyboard.rs

@@ -1,97 +0,0 @@
-extern crate alloc;
-
-use core::{
-    pin::Pin,
-    task::{Context, Poll},
-};
-
-use crate::prelude::*;
-use crossbeam::queue::ArrayQueue;
-use futures_util::{Stream, task::AtomicWaker};
-use spin::Once;
-
-static KBD_QUEUE: Once<ArrayQueue<u8>> = Once::new();
-static WAKER: AtomicWaker = AtomicWaker::new();
-
-pub fn add_scancode(scancode: u8) {
-    if let Some(queue) = KBD_QUEUE.get() {
-        if queue.push(scancode).is_err() {
-            println!("WARNING: scancode queue full; dropping keyboard input");
-        } else {
-            println!("waking waker");
-            WAKER.wake();
-        }
-    } else {
-        println!("WARNING: scancode queue not initialised");
-    }
-}
-
-pub struct ScanCodeStream {
-    _private: (),
-}
-
-impl ScanCodeStream {
-    pub fn new() -> Self {
-        KBD_QUEUE.call_once(|| ArrayQueue::new(5));
-
-        Self { _private: () }
-    }
-}
-
-impl Default for ScanCodeStream {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl Stream for ScanCodeStream {
-    type Item = u8;
-
-    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        let queue = KBD_QUEUE.get().expect("scancode queue not initialized");
-        serial_println!("This is called once.");
-        WAKER.register(cx.waker());
-
-        // fast path
-        if let Some(scancode) = queue.pop() {
-            return Poll::Ready(Some(scancode));
-        }
-
-        queue.pop().map_or_else(
-            || {
-                print!("Returning");
-                Poll::Pending
-            },
-            |scancode| {
-                print!("Scancode found");
-                WAKER.take();
-                Poll::Ready(Some(scancode))
-            },
-        )
-    }
-}
-
-use futures_util::stream::StreamExt;
-use pc_keyboard::{DecodedKey, HandleControl, Keyboard, ScancodeSet1, layouts};
-
-pub async fn print_keypresses() {
-    let mut scancodes = ScanCodeStream::new();
-    let mut keyboard = Keyboard::new(
-        ScancodeSet1::new(),
-        layouts::Us104Key,
-        HandleControl::Ignore,
-    );
-
-    serial_println!("Printing keypresses.");
-
-    while let Some(scancode) = scancodes.next().await {
-        if let Ok(Some(key_event)) = keyboard.add_byte(scancode) {
-            if let Some(key) = keyboard.process_keyevent(key_event) {
-                match key {
-                    DecodedKey::Unicode(character) => print!("{}", character),
-                    DecodedKey::RawKey(key) => print!("{:?}", key),
-                }
-            }
-        }
-    }
-}

libk/src/lib.rs

@@ -1,16 +1,47 @@
 #![no_std]
-#![warn(tail_expr_drop_order)]
-#![warn(clippy::correctness, clippy::perf, clippy::nursery)]
-// alloc
-// io : serial, framebuffer, ascii(?), keyboard
-// ?????
-// scheduling / tasks : async
+#![warn(
+    clippy::correctness,
+    clippy::nursery,
+    clippy::unnecessary_cast,
+    clippy::all,
+    clippy::suspicious,
+    clippy::perf,
+    rustdoc::missing_errors_doc,
+    rustdoc::missing_panics_doc,
+    tail_expr_drop_order
+)]
 
-pub mod alloc;
-pub mod io;
-pub mod scheduling;
+extern crate alloc;
 
-/// Re-exports most of the IO macros.
+pub mod drivers;
+pub mod resources;
+pub mod threads;
+pub mod util;
+
+#[allow(unused)] // We aren't using much of this right now.
+pub mod std;
+
+/// Re-exports most of the IO macros as well as standard allocation stuff
+#[allow(unused)]
 pub mod prelude {
-    pub use crate::{print, print_log, println, println_log, serial_print, serial_println};
+    pub use crate::std::io::*;
+    pub use alloc::{
+        boxed::Box,
+        string::{String, ToString},
+        vec::Vec,
+    };
 }
+
+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

@@ -0,0 +1,26 @@
+// use libm::include_font;
+
+use libm::include_font;
+
+pub mod ibm_vga_8x16;
+
+pub static FONT_SPLEEN_8X16: Font =
+    Font::new(include_font!("./libk/resources/font/spleen-8x16.psf"));
+
+pub static FONT_CP850_8X16: Font = Font::new(include_font!("./libk/resources/font/cp850-8x16.psf"));
+
+pub struct Font {
+    pub glyphs: [[u8; 16]; 512],
+}
+
+impl Default for Font {
+    fn default() -> Self {
+        Self::new([[0; 16]; 512])
+    }
+}
+
+impl Font {
+    pub const fn new(glyphs: [[u8; 16]; 512]) -> Self {
+        Self { glyphs }
+    }
+}

libk/src/resources/mod.rs

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

libk/src/std/application.rs

@@ -0,0 +1,21 @@
+use crate::prelude::*;
+
+mod frame;
+mod render;
+mod window;
+
+pub trait Application {
+    type Output;
+
+    fn run(
+        &mut self,
+        args: Vec<String>,
+    ) -> impl core::future::Future<Output = Result<Self::Output, Error>> + Send;
+}
+
+#[derive(Debug)]
+pub enum Error {
+    UnknownCommand(String),
+    ApplicationFailed(String),
+    KernelError(String),
+}

libk/src/std/application/frame.rs

@@ -0,0 +1,19 @@
+use super::{
+    render::{ColouredChar, RenderError},
+    window::Window,
+};
+use alloc::vec::Vec;
+
+pub struct Frame<'f> {
+    data: Vec<Vec<ColouredChar>>,
+    window: &'f Window,
+}
+
+impl Frame<'_> {
+    pub fn render(&self) -> Result<(), RenderError> {
+        let data: Vec<&[ColouredChar]> = self.data.iter().map(|v| v.as_slice()).collect::<Vec<_>>();
+        self.window
+            .render(data.as_slice())
+            .map_err(|_| RenderError::Generic)
+    }
+}

libk/src/std/application/render.rs

@@ -0,0 +1,23 @@
+use core::fmt::Display;
+
+use crate::drivers::io::framebuffer::colour::Colour;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum RenderError {
+    Generic,
+}
+
+impl Display for RenderError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Self::Generic => write!(f, "Generic render error"),
+        }
+    }
+}
+
+impl core::error::Error for RenderError {}
+
+pub struct ColouredChar {
+    ch: u8,
+    colour: Colour,
+}

libk/src/std/application/window.rs

@@ -0,0 +1,86 @@
+use crate::{prelude::*, std::maths::geometry::Vec2};
+
+use super::render::{ColouredChar, RenderError};
+
+pub struct Window {
+    dimensions: Vec2<usize>,
+    position: Vec2<usize>,
+    bordered: bool,
+    opened: bool,
+    title: String,
+}
+
+impl Window {
+    pub const fn new() -> Self {
+        Self {
+            dimensions: Vec2::new(0, 0),
+            position: Vec2::new(0, 0),
+            bordered: true,
+            opened: false,
+            title: String::new(),
+        }
+    }
+
+    pub fn render(&self, _data: &[&[ColouredChar]]) -> Result<(), RenderError> {
+        todo!();
+    }
+
+    pub const fn is_bordered(&self) -> bool {
+        self.bordered
+    }
+
+    pub const fn is_open(&self) -> bool {
+        self.opened
+    }
+
+    pub const fn open(&mut self) {
+        self.opened = true;
+    }
+
+    pub const fn close(&mut self) {
+        self.opened = false;
+    }
+
+    // some basic getters and setters for utility.
+    pub fn title(&'static self) -> &'static str {
+        self.title.as_str()
+    }
+
+    pub const fn dimensions(&self) -> Vec2<usize> {
+        self.dimensions
+    }
+
+    pub const fn position(&self) -> Vec2<usize> {
+        self.position
+    }
+
+    pub fn set_title(&mut self, title: String) {
+        self.title = title;
+    }
+
+    pub fn move_window(&mut self, offset: Vec2<usize>) {
+        self.position += offset;
+    }
+
+    pub const fn set_position(&mut self, position: Vec2<usize>) {
+        self.position = position;
+    }
+
+    pub const fn set_dimensions(&mut self, dimensions: Vec2<usize>) {
+        self.dimensions = dimensions;
+    }
+}
+
+impl Default for Window {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Drop for Window {
+    fn drop(&mut self) {
+        if self.opened {
+            self.close();
+        }
+    }
+}

libk/src/std/io.rs

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

libk/src/std/maths/geometry.rs

@@ -0,0 +1,73 @@
+use core::ops::{AddAssign, DivAssign, MulAssign, SubAssign};
+
+pub trait Coordinate:
+    Copy + Clone + PartialEq + AddAssign + MulAssign + SubAssign + DivAssign
+{
+}
+
+impl Coordinate for usize {}
+impl Coordinate for isize {}
+impl Coordinate for u8 {}
+impl Coordinate for i8 {}
+impl Coordinate for u16 {}
+impl Coordinate for i16 {}
+impl Coordinate for u32 {}
+impl Coordinate for i32 {}
+impl Coordinate for u64 {}
+impl Coordinate for i64 {}
+impl Coordinate for u128 {}
+impl Coordinate for i128 {}
+impl Coordinate for f32 {}
+impl Coordinate for f64 {}
+
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Debug)]
+pub struct Vec2<T: Coordinate> {
+    x: T,
+    y: T,
+}
+
+impl<T: Coordinate> Vec2<T> {
+    pub const fn new(x: T, y: T) -> Self {
+        Self { x, y }
+    }
+
+    pub fn into<S: Coordinate + From<T>>(&self) -> Vec2<S> {
+        Vec2::new(self.x.into(), self.y.into())
+    }
+
+    pub const fn x(&self) -> T {
+        self.x
+    }
+
+    pub const fn y(&self) -> T {
+        self.y
+    }
+}
+
+impl<T: Coordinate> AddAssign for Vec2<T> {
+    fn add_assign(&mut self, rhs: Self) {
+        self.x += rhs.x;
+        self.y += rhs.y;
+    }
+}
+
+impl<T: Coordinate> SubAssign for Vec2<T> {
+    fn sub_assign(&mut self, rhs: Self) {
+        self.x -= rhs.x;
+        self.y -= rhs.y;
+    }
+}
+
+impl<T: Coordinate> MulAssign<T> for Vec2<T> {
+    fn mul_assign(&mut self, rhs: T) {
+        self.x *= rhs;
+        self.y *= rhs;
+    }
+}
+
+impl<T: Coordinate> DivAssign<T> for Vec2<T> {
+    fn div_assign(&mut self, rhs: T) {
+        self.x /= rhs;
+        self.y /= rhs;
+    }
+}

libk/src/std/maths/mod.rs

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

libk/src/std/mod.rs

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

libk/src/threads.rs

@@ -0,0 +1,113 @@
+use core::arch::asm;
+
+#[repr(C)]
+pub struct Thread {
+    id: usize,
+    /// This shall be default before the program is interrupted, otherwise it will store
+    /// CPU registers etc to be restored on context switch.
+    ctx: ThreadContext,
+}
+
+/// CPU state to be saved on context switches.
+#[repr(C)]
+#[derive(Default)]
+pub struct ThreadContext {
+    /// Accumulator register.
+    rax: u64,
+    /// Base register.
+    rbx: u64,
+    /// Counter register.
+    rcx: u64,
+    /// Data register.
+    rdx: u64,
+    /// Source index register.
+    rsi: u64,
+    /// Destination index register.
+    rdi: u64,
+    /// Base pointer register.
+    rbp: u64,
+    /// Stack pointer register.
+    rsp: u64,
+    /// An extended register.
+    r8: u64,
+    /// An extended register.
+    r9: u64,
+    /// An extended register.
+    r10: u64,
+    /// An extended register.
+    r11: u64,
+    /// An extended register.
+    r12: u64,
+    /// An extended register.
+    r13: u64,
+    /// An extended register.
+    r14: u64,
+    /// An extended register.
+    r15: u64,
+    /// The instruction pointer.
+    rip: u64,
+    /// RFLAGS register.
+    rflags: u64,
+}
+
+impl ThreadContext {
+    /// Saves the current registers of the CPU before a context switch
+    /// to be restored later.
+    ///
+    /// # Notes
+    ///
+    /// This function should ONLY be called in interrupt handlers such
+    /// as that of the timer. This will then save registers as required
+    ///
+    ///
+    /// # Safety
+    ///
+    /// This function is unsafe because of the usage of inline ASM.
+    #[inline(always)]
+    pub unsafe fn save_registers() -> Self {
+        let mut context = Self::default();
+        unsafe {
+            asm!(
+                "mov {0}, rax",
+                "mov {1}, rbx",
+                "mov {2}, rcx",
+                "mov {3}, rdx",
+                "mov {4}, rsi",
+                "mov {5}, rdi",
+                "mov {6}, rbp",
+                "mov {7}, rsp",
+                "mov {8}, r8",
+                "mov {9}, r9",
+                "mov {10}, r10",
+                "mov {11}, r11",
+                "mov {12}, r12",
+                "mov {13}, r13",
+                "mov {14}, r14",
+                "mov {15}, r15",
+                "lea {16}, [rip]",
+                "pushf",
+                "pop {17}",
+                out(reg) context.rax,
+                out(reg) context.rbx,
+                out(reg) context.rcx,
+                out(reg) context.rdx,
+                out(reg) context.rsi,
+                out(reg) context.rdi,
+                out(reg) context.rbp,
+                out(reg) context.rsp,
+                out(reg) context.r8,
+                out(reg) context.r9,
+                out(reg) context.r10,
+                out(reg) context.r11,
+                out(reg) context.r12,
+                out(reg) context.r13,
+                out(reg) context.r14,
+                out(reg) context.r15,
+                out(reg) context.rip,
+                out(reg) context.rflags,
+            );
+        }
+
+        context
+    }
+}

libk/src/util/mod.rs

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

libk/src/util/shell.rs

@@ -0,0 +1,40 @@
+// use x86_64::registers::rflags::read;
+
+use crate::{drivers::io::ascii::clear_screen, prelude::stdin::read_line, print, println};
+
+static FETCH: &str = "
+        $$$$$$$$\\                                  $$\\                     
+        $$  _____|                                 $$ |                    
+        $$ |    $$$$$$\\  $$\\   $$\\ $$$$$$$\\   $$$$$$$ | $$$$$$\\  $$\\   $$\\ 
+        $$$$$\\ $$  __$$\\ $$ |  $$ |$$  __$$\\ $$  __$$ |$$  __$$\\ $$ |  $$ |
+        $$  __|$$ /  $$ |$$ |  $$ |$$ |  $$ |$$ /  $$ |$$ |  \\__|$$ |  $$ |
+        $$ |   $$ |  $$ |$$ |  $$ |$$ |  $$ |$$ |  $$ |$$ |      $$ |  $$ |
+        $$ |   \\$$$$$$  |\\$$$$$$  |$$ |  $$ |\\$$$$$$$ |$$ |      \\$$$$$$$ |
+        \\__|    \\______/  \\______/ \\__|  \\__| \\_______|\\__|       \\____$$ |
+             $$$$$$\\   $$$$$$\\        $$\\    $$\\   $$\\           $$\\   $$ |
+            $$  __$$\\ $$  __$$\\       $$ |   $$ |$$$$ |          \\$$$$$$  |
+            $$ /  $$ |$$ /  \\__|      $$ |   $$ |\\_$$ |           \\______/ 
+            $$ |  $$ |\\$$$$$$\\        \\$$\\  $$  |  $$ |                  
+            $$ |  $$ | \\____$$\\        \\$$\\$$  /   $$ |                  
+            $$ |  $$ |$$\\   $$ |        \\$$$  /    $$ |                  
+             $$$$$$  |\\$$$$$$  |         \\$  /   $$$$$$\\                 
+             \\______/  \\______/           \\_/    \\______|                              
+";
+
+pub async fn shell() {
+    println!("{}", FETCH);
+
+    loop {
+        print!(" Shell> ");
+        let line = read_line().await;
+        match line.as_str() {
+            "fetch" => {
+                println!("{}", FETCH);
+            }
+            "clear" => clear_screen(),
+            _ => {
+                println!("Unknown command: {}", line);
+            }
+        }
+    }
+}

libm/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "libm"
+version.workspace = true
+edition.workspace = true
+authors.workspace = true
+
+[dependencies]
+darling = "0.20.10"
+proc-macro2 = "1.0.93"
+quote = "1.0.38"
+syn = "2.0.98"
+
+
+[lib]
+proc-macro = true

libm/src/lib.rs

@@ -0,0 +1,99 @@
+#![warn(
+    clippy::correctness,
+    clippy::nursery,
+    clippy::unnecessary_cast,
+    clippy::all,
+    clippy::suspicious,
+    clippy::perf,
+    rustdoc::missing_errors_doc,
+    rustdoc::missing_panics_doc
+)]
+
+use std::fs::File;
+use std::io::{Read, Seek, SeekFrom};
+
+use proc_macro::TokenStream;
+use quote::quote;
+use syn::{LitStr, parse_macro_input};
+
+extern crate proc_macro;
+
+#[proc_macro]
+pub fn include_font(item: TokenStream) -> TokenStream {
+    let filename = parse_macro_input!(item as LitStr);
+    let file_path = filename.value();
+
+    println!("Loading font: [{}]", file_path);
+
+    let font_bytes = match load_file(file_path) {
+        Ok(bytes) => bytes,
+        Err(why) => panic!("{}", why),
+    };
+
+    let font_data = match Font::new(font_bytes) {
+        Ok(font) => font.0,
+        Err(why) => panic!("{}", why),
+    };
+
+    quote!(
+        [
+            #(
+                [#(#font_data),*]
+            ),*
+        ]
+    )
+    .into()
+}
+
+struct Font([[u8; 16]; 512]);
+
+impl Font {
+    const MAGIC: u16 = 0x3604;
+
+    pub fn new(data: [u8; (32 + 2) * 512 + 4]) -> Result<Self, &'static str> {
+        let magic: u16 = (data[0] as u16) << 8 | data[1] as u16;
+        let mode = data[2];
+        let size = data[3];
+
+        if magic != Self::MAGIC {
+            return Err("Magic value is invalid!");
+        }
+
+        let has_512_glyphs = (mode & 0x01) != 0;
+        let mut glyphs = [[0; 16]; 512];
+        let glyph_count = if has_512_glyphs { 512 } else { 256 };
+
+        for i in 0..(glyph_count as usize) {
+            let mut buff: [u8; 16] = [0; 16];
+            for j in 0..(size as usize) {
+                buff[j] = data[4 + i * (size as usize) + j];
+            }
+            glyphs[i] = buff;
+        }
+
+        Ok(Self(glyphs))
+    }
+}
+
+type FileContents = [u8; (32 + 2) * 512 + 4];
+fn load_file(filename: String) -> Result<FileContents, std::io::Error> {
+    let mut buf = [0; (32 + 2) * 512 + 4];
+    let mut f = File::open(filename).unwrap();
+    f.seek(SeekFrom::Start(0)).unwrap();
+
+    loop {
+        match f.read(&mut buf) {
+            Ok(read) => {
+                if read == 0 {
+                    break;
+                }
+            }
+            Err(why) => {
+                eprintln!("Failed to read PS1 font file: {}", why);
+                return Err(why);
+            }
+        }
+    }
+
+    Ok(buf)
+}

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/run_debug.sh

@@ -2,120 +2,16 @@
 
 # Script originally written by zxq5, I added separate scripts to remove `jq` dependency.
 
-# 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
+script_dir=$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" &>/dev/null && pwd)
+
+source $script_dir/build.sh
 
 # 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"
@@ -145,6 +41,31 @@ else
     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
+#   Check for the presence of the OVMF firmware.
+    if [ ! -f $build_dir/RELEASEX64_OVMF_CODE.fd ]; then
+        info "Downloading OVMF UEFI firmware for QEMU"
+        info "To disable this, set USE_LEGACY_BIOS=1."
+        pushd $build_dir
+        curl https://retrage.github.io/edk2-nightly/bin/RELEASEX64_OVMF_CODE.fd -LO || error "failed to download OVMF firmware for UEFI"
+        curl https://retrage.github.io/edk2-nightly/bin/RELEASEX64_OVMF_VARS.fd -LO || error "failed to download OVMF firmware for UEFI"
+        popd
+    fi
+
+    boot_flags="-drive if=pflash,format=raw,readonly=on,file=$build_dir/RELEASEX64_OVMF_CODE.fd \
+                -drive if=pflash,format=raw,file=$build_dir/RELEASEX64_OVMF_VARS.fd"
+fi
+
 # Run in QEMU
 if [[ ${QEMU_FLAGS} == *-S* ]]; then
     info "Running OS in QEMU with GDB debugging enabled"
@@ -171,20 +92,18 @@ check_test_res() {
     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" \
+    ${kvm_flag} \
     -boot d \
-    -m 2G \
+    ${vm_memory_flag} \
     ${serial_flags} \
     -no-reboot \
     ${test_flags} \
     ${debug_flags} \
+    ${boot_flags} \
     ${QEMU_FLAGS:-}
 

scripts/run_release.sh

@@ -2,120 +2,23 @@
 
 # Script originally written by zxq5, I added separate scripts to remove `jq` dependency.
 
-# 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
+script_dir=$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" &>/dev/null && pwd)
+
+source $script_dir/build.sh
 
 # 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() {
-    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"
+if [ $VM_MEMORY ]; then
+    vm_memory_flag="-m $VM_MEMORY"
 else
-    # Build the kernel normally
-    cd "$project_root"
-    # cargo build
-    kernel_path="$build_dir/target/x86_64-kernel/release/kernel"
+    vm_memory_flag="-m 2G"
 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,59 +31,30 @@ else
     kvm_flag=""
 fi
 
-# I'm lazy but I just remove GDB flags when running this script.
-debug_flags=""
-
-# 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"
+if [ $USE_LEGACY_BIOS ]; then
+    boot_flags=""
 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
+#   Check for the presence of the OVMF firmware.
+    if [ ! -f $build_dir/RELEASEX64_OVMF_CODE.fd ]; then
+        info "Downloading OVMF UEFI firmware for QEMU"
+        info "To disable this, set USE_LEGACY_BIOS=1."
+        pushd $build_dir
+        curl https://retrage.github.io/edk2-nightly/bin/RELEASEX64_OVMF_CODE.fd -LO || error "failed to download OVMF firmware for UEFI"
+        curl https://retrage.github.io/edk2-nightly/bin/RELEASEX64_OVMF_VARS.fd -LO || error "failed to download OVMF firmware for UEFI"
+        popd
     fi
-}
 
+    boot_flags="-drive if=pflash,format=raw,readonly=on,file=$build_dir/RELEASEX64_OVMF_CODE.fd \
+                -drive if=pflash,format=raw,file=$build_dir/RELEASEX64_OVMF_VARS.fd"
+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} \
-    ${debug_flags} \
-    ${QEMU_FLAGS:-}
+    ${boot_flags}