Merge pull request 'dev' (#4) from dev into main

Reviewed-on: OsDev/FoundryOS#4

.cargo/config.toml

@@ -3,7 +3,7 @@ target = "x86_64-kernel"
 target-dir = "build/target"
 
 [unstable]
-build-std = ["core", "compiler_builtins"]
+build-std = ["core", "compiler_builtins", "alloc"]
 build-std-features = ["compiler-builtins-mem"]
 
 [env]

.gitea/workflows/rust.yml

@@ -0,0 +1,22 @@
+on:
+  push:
+    branches: [ main ]
+  pull-request:
+    branches: [ main ]
+
+name: Continuous integration
+
+jobs: 
+  build:
+    name: build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions-rust-lang/setup-rust-toolchain@v1
+        with:
+          target: x86_64-unknown-none
+          components: rust-src, llvm-tools-preview
+          toolchain: nightly
+      - uses: actions/checkout@v4
+        with:
+          submodules: true
+      - run: cargo build

.gitmodules

@@ -0,0 +1,15 @@
+[submodule "lib/lib_application"]
+	path = lib/lib_application
+	url = https://git.zxq5.dev/OsDev/FoundryOS-lib_application.git
+[submodule "lib/lib_ascii"]
+	path = lib/lib_ascii
+	url = https://git.zxq5.dev/OsDev/FoundryOS-lib_ascii.git
+[submodule "lib/lib_framebuffer"]
+	path = lib/lib_framebuffer
+	url = https://git.zxq5.dev/OsDev/FoundryOS-lib_framebuffer.git
+[submodule "lib/lib_serial"]
+	path = lib/lib_serial
+	url = https://git.zxq5.dev/OsDev/FoundryOS-lib_serial.git
+[submodule "lib/lib_alloc"]
+	path = lib/lib_alloc
+	url = https://git.zxq5.dev/OsDev/FoundryOS-lib_alloc.git

.vscode/settings.json

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

Cargo.lock

@@ -30,14 +30,19 @@ dependencies = [
 ]
 
 [[package]]
-name = "kernel"
+name = "foundry_os"
 version = "0.1.0"
 dependencies = [
  "cc",
+ "lib_alloc",
  "lib_ascii",
  "lib_framebuffer",
  "lib_serial",
  "limine",
+ "pc-keyboard",
+ "pic8259",
+ "spin",
+ "x86_64",
 ]
 
 [[package]]
@@ -49,6 +54,14 @@ dependencies = [
  "spin",
 ]
 
+[[package]]
+name = "lib_alloc"
+version = "0.1.0"
+dependencies = [
+ "linked_list_allocator",
+ "x86_64",
+]
+
 [[package]]
 name = "lib_application"
 version = "0.1.0"
@@ -92,6 +105,15 @@ dependencies = [
  "bitflags",
 ]
 
+[[package]]
+name = "linked_list_allocator"
+version = "0.10.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9afa463f5405ee81cdb9cc2baf37e08ec7e4c8209442b5d72c04cfb2cd6e6286"
+dependencies = [
+ "spinning_top",
+]
+
 [[package]]
 name = "lock_api"
 version = "0.4.12"
@@ -102,6 +124,21 @@ dependencies = [
  "scopeguard",
 ]
 
+[[package]]
+name = "pc-keyboard"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0ca629cbb3f0d5b699c338f0129ff78c9bfd7ea8b1258ad529bff490dc8ed5a"
+
+[[package]]
+name = "pic8259"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62d9a86c292b165f757e47e7fd66855def189b2564609bc4203727b27c33db22"
+dependencies = [
+ "x86_64",
+]
+
 [[package]]
 name = "rustversion"
 version = "1.0.19"
@@ -129,6 +166,15 @@ dependencies = [
  "lock_api",
 ]
 
+[[package]]
+name = "spinning_top"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b9eb1a2f4c41445a3a0ff9abc5221c5fcd28e1f13cd7c0397706f9ac938ddb0"
+dependencies = [
+ "lock_api",
+]
+
 [[package]]
 name = "volatile"
 version = "0.4.6"

Cargo.toml

@@ -3,8 +3,10 @@ members = [
     "lib/lib_framebuffer",
     "lib/lib_serial",
     "lib/lib_ascii",
-    "kernel"
-, "lib/lib_application"]
+    "kernel",
+    "lib/lib_application", 
+    "lib/lib_alloc",
+]
 resolver = "2"
 
 [workspace.package]
@@ -21,11 +23,10 @@ incremental = false
 codegen-units = 1
 
 [profile.release]
-opt-level = "z"
+opt-level = 3
 debug = false
 debug-assertions = false
 overflow-checks = false
 lto = true
 incremental = false
 codegen-units = 1
-

README.md

@@ -1,2 +1,22 @@
 # FoundryOS
 
+## Cloning and building
+
+Here are some simple steps to get started:
+
+```sh
+# If you have not yet cloned the repo:
+git clone --recurse-submodules https://git.zxq5.dev/OsDev/FoundryOS.git
+# If you already cloned the repo:
+git submodule update --init --recursive
+
+cargo build
+# This will build the binaries if required - no need to call cargo build.
+cargo run
+```
+
+### Build dependencies
+
+* jq: checks whether the app is to be run in debugging mode.
+* libisoburn: creates ISO images to be booted from.
+* qemu: to run the kernel.

kernel/Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "kernel"
+name = "foundry_os"
 version = "0.1.0"
 edition = "2021"
 
@@ -8,6 +8,11 @@ limine = "0.3.1"
 lib_framebuffer = { path = "../lib/lib_framebuffer" }
 lib_serial = { path = "../lib/lib_serial" }
 lib_ascii = { path = "../lib/lib_ascii" }
+lib_alloc = { path = "../lib/lib_alloc" }
+x86_64 = "0.15.2"
+spin = "0.9.8"
+pic8259 = "0.11.0"
+pc-keyboard = "0.8.0"
 
 [build-dependencies]
 cc = "1.2.14"

kernel/build.rs

@@ -1,6 +1,6 @@
+use cc;
 use std::process::Command;
 use std::{env, path::Path};
-use cc;
 
 fn main() {
     // Tell cargo to rerun if these files change

kernel/src/arch/mod.rs

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

kernel/src/arch/x86_64/gdt.rs

@@ -0,0 +1,69 @@
+use x86_64::{
+    instructions::tables::load_tss,
+    registers::segmentation::{Segment, CS, DS, ES, SS},
+    structures::{
+        gdt::{Descriptor, GlobalDescriptorTable, SegmentSelector},
+        tss::TaskStateSegment,
+    },
+    VirtAddr,
+};
+
+use spin::Lazy;
+
+pub const DOUBLE_FAULT_1ST_INDEX: u16 = 0;
+
+static TSS: Lazy<TaskStateSegment> = Lazy::new(|| {
+    let mut tss = TaskStateSegment::new();
+    tss.interrupt_stack_table[DOUBLE_FAULT_1ST_INDEX as usize] = {
+        const STACK_SIZE: usize = 4096 * 8;
+        static mut STACK: [u8; STACK_SIZE] = [0; STACK_SIZE];
+
+        let stack_start = VirtAddr::from_ptr(&raw const STACK);
+        let stack_end = stack_start + STACK_SIZE.try_into().unwrap();
+        stack_end
+    };
+    tss
+});
+
+static GDT: Lazy<(GlobalDescriptorTable, Selectors)> = Lazy::new(|| {
+    let mut gdt = GlobalDescriptorTable::new();
+    let code_selector = gdt.append(Descriptor::kernel_code_segment());
+    let data_selector = gdt.append(Descriptor::kernel_data_segment());
+
+    let user_code_selector = gdt.append(Descriptor::user_code_segment());
+    let user_data_selector = gdt.append(Descriptor::user_data_segment());
+
+    let tss_selector = gdt.append(Descriptor::tss_segment(&TSS));
+
+    (
+        gdt,
+        Selectors {
+            code_selector,
+            data_selector,
+            user_code_selector,
+            user_data_selector,
+            tss_selector,
+        },
+    )
+});
+
+struct Selectors {
+    code_selector: SegmentSelector,
+    data_selector: SegmentSelector,
+    user_code_selector: SegmentSelector,
+    user_data_selector: SegmentSelector,
+    tss_selector: SegmentSelector,
+}
+
+pub fn init() {
+    GDT.0.load();
+
+    unsafe {
+        CS::set_reg(GDT.1.code_selector);
+        load_tss(GDT.1.tss_selector);
+
+        DS::set_reg(self::GDT.1.data_selector);
+        ES::set_reg(self::GDT.1.data_selector);
+        SS::set_reg(self::GDT.1.data_selector);
+    }
+}

kernel/src/arch/x86_64/interrupts.rs

@@ -0,0 +1,132 @@
+use lib_ascii::{print, println_log};
+use lib_serial::serial_println;
+use x86_64::instructions::port::Port;
+use x86_64::registers::control::Cr2;
+use x86_64::structures::idt::{InterruptDescriptorTable, InterruptStackFrame, PageFaultErrorCode};
+
+use pic8259::ChainedPics;
+use spin::{Lazy, Mutex};
+
+use super::gdt;
+
+static IDT: Lazy<InterruptDescriptorTable> = Lazy::new(|| {
+    let mut idt = InterruptDescriptorTable::new();
+    idt.breakpoint.set_handler_fn(breakpoint_handler);
+
+    unsafe {
+        idt.double_fault
+            .set_handler_fn(double_fault_handler)
+            .set_stack_index(gdt::DOUBLE_FAULT_1ST_INDEX);
+    }
+
+    idt.general_protection_fault
+        .set_handler_fn(general_protection_fault_handler);
+    idt.page_fault.set_handler_fn(page_fault_handler);
+
+    idt[InterruptIndex::Timer.as_u8()].set_handler_fn(timer_interrupt_handler);
+    idt[InterruptIndex::Keyboard.as_u8()].set_handler_fn(keyboard_interrupt_handler);
+    idt
+});
+
+pub const PIC_1_OFFSET: u8 = 32;
+pub const PIC_2_OFFSET: u8 = PIC_1_OFFSET + 8;
+
+pub static PICS: Mutex<ChainedPics> =
+    Mutex::new(unsafe { ChainedPics::new(PIC_1_OFFSET, PIC_2_OFFSET) });
+
+#[derive(Debug, Clone, Copy)]
+#[repr(u8)]
+pub enum InterruptIndex {
+    Timer = PIC_1_OFFSET,
+    Keyboard,
+}
+
+impl InterruptIndex {
+    fn as_u8(self) -> u8 {
+        self as u8
+    }
+
+    fn _as_usize(self) -> usize {
+        usize::from(self.as_u8())
+    }
+}
+
+pub fn init_idt() {
+    IDT.load();
+    unsafe {
+        PICS.lock().initialize();
+        PICS.lock().write_masks(0xfc, 0xff);
+    }
+}
+
+extern "x86-interrupt" fn breakpoint_handler(stack_frame: InterruptStackFrame) {
+    serial_println!("Exception: Breakpoint\n{:#?}", stack_frame);
+    println_log!("Exception: Breakpoint\n{:#?}", stack_frame);
+}
+
+extern "x86-interrupt" fn general_protection_fault_handler(
+    stack_frame: InterruptStackFrame,
+    _error_code: u64,
+) {
+    serial_println!("Exception: General Protection Fault\n{:#?}", stack_frame);
+    panic!("Exception: General Protection Fault\n{:#?}", stack_frame);
+}
+
+extern "x86-interrupt" fn double_fault_handler(
+    stack_frame: InterruptStackFrame,
+    _error_code: u64,
+) -> ! {
+    serial_println!("Exception: Double Fault\n{:#?}", stack_frame);
+    panic!("Exception: Double Fault\n{:#?}", stack_frame);
+}
+
+extern "x86-interrupt" fn keyboard_interrupt_handler(_stack_frame: InterruptStackFrame) {
+    use pc_keyboard::{layouts, DecodedKey, HandleControl, Keyboard, ScancodeSet1};
+    use spin::Mutex;
+    use x86_64::instructions::port::Port;
+
+    static KEYBOARD: Lazy<Mutex<Keyboard<layouts::Us104Key, ScancodeSet1>>> = Lazy::new(|| {
+        Mutex::new(Keyboard::new(
+            ScancodeSet1::new(),
+            layouts::Us104Key,
+            HandleControl::Ignore,
+        ))
+    });
+
+    let mut keyboard = KEYBOARD.lock();
+    let mut port = Port::new(0x60);
+
+    let scancode: u8 = unsafe { port.read() };
+    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),
+            }
+        }
+    }
+
+    unsafe {
+        PICS.lock()
+            .notify_end_of_interrupt(InterruptIndex::Keyboard.as_u8());
+    }
+}
+
+extern "x86-interrupt" fn timer_interrupt_handler(_stack_frame: InterruptStackFrame) {
+    unsafe {
+        PICS.lock()
+            .notify_end_of_interrupt(InterruptIndex::Timer.as_u8());
+    }
+}
+
+extern "x86-interrupt" fn page_fault_handler(
+    stack_frame: InterruptStackFrame,
+    error_code: PageFaultErrorCode,
+) {
+    serial_println!("Exception: Page Fault");
+    serial_println!("Accessed Address: {:?}", Cr2::read());
+    serial_println!("Error Code: {:?}", error_code);
+    serial_println!("{:#?}", stack_frame);
+
+    crate::hcf();
+}

kernel/src/arch/x86_64/memmap.rs

@@ -0,0 +1,56 @@
+//! Sets up a memory map using Limine.
+
+use limine::{
+    request::{HhdmRequest, KernelAddressRequest, MemoryMapRequest},
+    response::MemoryMapResponse,
+};
+use spin::Lazy;
+
+#[used]
+#[link_section = ".requests"]
+static MEMORY_MAP_REQUEST: MemoryMapRequest = MemoryMapRequest::new();
+
+#[used]
+#[link_section = ".requests"]
+static HIGHER_HALF_DIRECT_MAP_REQUEST: HhdmRequest = HhdmRequest::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.
+/// ```
+pub static PHYSICAL_MEMORY_OFFSET: Lazy<u64> = Lazy::new(|| {
+    HIGHER_HALF_DIRECT_MAP_REQUEST
+        .get_response()
+        .unwrap()
+        .offset()
+});
+
+#[used]
+#[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;
+/// ```
+///
+/// Returns (virtual_base, physical_base)
+pub static KERNEL_PHYSICAL_MEMORY_OFFSET: Lazy<(u64, u64)> = Lazy::new(|| {
+    let resp = KERNEL_ADDRESS_REQUEST.get_response().unwrap();
+
+    // These are base addresses, using Limine's built in page table.
+    (resp.virtual_base(), resp.physical_base())
+});
+
+/// Fetches the memory map from Limine.
+///
+/// # Panics
+///
+/// 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() {
+        return memory_map;
+    } else {
+        unreachable!("Could not fetch memory map from Limine.")
+    }
+}

kernel/src/arch/x86_64/memory.rs

@@ -0,0 +1,134 @@
+use lib_alloc::allocator::FoundryAllocator;
+use limine::{memory_map::EntryType, response::MemoryMapResponse};
+use x86_64::{
+    addr,
+    registers::control::Cr3,
+    structures::paging::{
+        page_table::FrameError, FrameAllocator, OffsetPageTable, PageTable, PhysFrame, Size4KiB,
+    },
+    PhysAddr, VirtAddr,
+};
+
+/// 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();
+    &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> {
+    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> {
+        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

@@ -0,0 +1,7 @@
+pub mod gdt;
+
+pub mod interrupts;
+
+pub mod memory;
+
+pub(crate) mod memmap;

kernel/src/lib.rs

@@ -0,0 +1,95 @@
+#![no_std]
+#![feature(abi_x86_interrupt)]
+
+extern crate alloc;
+
+use core::arch::asm;
+use lib_alloc::allocator::init_heap;
+use limine::request::{RequestsEndMarker, RequestsStartMarker};
+use limine::BaseRevision;
+
+pub use lib_ascii::{print, print_log, println, println_log, WRITER};
+pub use lib_serial::{serial_print, serial_println, serial_read};
+use x86_64::structures::paging::Translate;
+use x86_64::{PhysAddr, VirtAddr};
+
+mod arch;
+
+/// Sets the base revision to the latest revision supported by the crate.
+/// See specification for further info.
+/// Be sure to mark all limine requests with #[used], otherwise they may be removed by the compiler.
+#[used]
+// The .requests section allows limine to find the requests faster and more safely.
+#[link_section = ".requests"]
+static BASE_REVISION: BaseRevision = BaseRevision::new();
+
+/// Define the stand and end markers for Limine requests.
+#[used]
+#[link_section = ".requests_start_marker"]
+static _START_MARKER: RequestsStartMarker = RequestsStartMarker::new();
+#[used]
+#[link_section = ".requests_end_marker"]
+static _END_MARKER: RequestsEndMarker = RequestsEndMarker::new();
+
+#[panic_handler]
+fn rust_panic(_info: &core::panic::PanicInfo) -> ! {
+    println!("Kernel panic: {}", _info);
+    serial_println!("Kernel panic: {}", _info);
+    hcf();
+}
+
+pub fn hcf() -> ! {
+    loop {
+        unsafe {
+            #[cfg(target_arch = "x86_64")]
+            asm!("hlt");
+            #[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
+            asm!("wfi");
+            #[cfg(target_arch = "loongarch64")]
+            asm!("idle 0");
+        }
+    }
+}
+
+pub fn boot() -> Result<(), &'static str> {
+    if !BASE_REVISION.is_supported() {
+        return Err("base revision not supported");
+    }
+
+    use arch::x86_64::{gdt, interrupts, memmap, memory};
+
+    let memory_map = memmap::get_memory_map();
+
+    print_log!("    Initialising Serial... ");
+    lib_serial::init()?;
+    println_log!("[Success]");
+
+    print_log!("    Setting Up Global Descriptor Table... ");
+    gdt::init();
+    println_log!("[Success]");
+
+    print_log!("    Setting Up Interrupt Descriptor Table... ");
+    interrupts::init_idt();
+    println_log!("[Success]");
+
+    print_log!("    Setting Up Page Table... ");
+    let mut frame_allocator = unsafe { memory::FoundryOSFrameAllocator::init(memory_map) };
+    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) };
+    println_log!("[Success]");
+
+    print_log!("    Initialising Heap... ");
+    if let Err(e) = init_heap(&mut l4_table, &mut frame_allocator) {
+        return Err("Failed to initialise heap");
+    }
+    println_log!("[Success]");
+
+    print_log!("    Enabling Interrupts... ");
+    x86_64::instructions::interrupts::enable();
+    println_log!("[Success]");
+
+    Ok(())
+}

kernel/src/main.rs

@@ -1,50 +1,32 @@
 #![no_std]
 #![no_main]
 
-use core::arch::asm;
+extern crate alloc;
 
-use lib_serial::{serial_println, serial_read};
-use lib_ascii::{print, println, WRITER};
+use alloc::vec::Vec;
 
-use limine::request::{RequestsEndMarker, RequestsStartMarker};
-use limine::BaseRevision;
-
-use lib_framebuffer;
-
-/// Sets the base revision to the latest revision supported by the crate.
-/// See specification for further info.
-/// Be sure to mark all limine requests with #[used], otherwise they may be removed by the compiler.
-#[used]
-// The .requests section allows limine to find the requests faster and more safely.
-#[link_section = ".requests"]
-static BASE_REVISION: BaseRevision = BaseRevision::new();
-
-/// Define the stand and end markers for Limine requests.
-#[used]
-#[link_section = ".requests_start_marker"]
-static _START_MARKER: RequestsStartMarker = RequestsStartMarker::new();
-#[used]
-#[link_section = ".requests_end_marker"]
-static _END_MARKER: RequestsEndMarker = RequestsEndMarker::new();
+use foundry_os::{println, println_log};
 
 #[no_mangle]
 unsafe extern "C" fn kmain() -> ! {
     // All limine requests must also be referenced in a called function, otherwise they may be
     // removed by the linker.
-    assert!(BASE_REVISION.is_supported());
 
-
-    if let Err(_) = lib_serial::init() {
-        loop {}
+    println_log!(" [ Initialising Kernel Systems ] ");
+    if let Err(err) = foundry_os::boot() {
+        panic!("{}", err);
     }
 
+    println_log!("[ Kernel Initialised Successfully ] ");
+
     let dimensions = lib_ascii::screensize_chars();
     let dimensions2 = lib_framebuffer::screensize_px();
-    println!("Hello World!");
+
     println!("Dimensions: {}x{} (px)", dimensions2.0, dimensions2.1);
     println!("Dimensions: {}x{} (chars)", dimensions.0, dimensions.1);
 
-    println!("
+    println!(
+        "
         $$$$$$$$\\                                  $$\\                     
         $$  _____|                                 $$ |                    
         $$ |    $$$$$$\\  $$\\   $$\\ $$$$$$$\\   $$$$$$$ | $$$$$$\\  $$\\   $$\\ 
@@ -61,29 +43,8 @@ unsafe extern "C" fn kmain() -> ! {
             $$ |  $$ |$$\\   $$ |        \\$$$  /    $$ |                  
              $$$$$$  |\\$$$$$$  |         \\$  /   $$$$$$\\                 
              \\______/  \\______/           \\_/    \\______|                              
-    ");
+    "
+    );
 
-    for i in 0u8..128 {
-        print!("{}", i as char);
-    }
-
-    hcf();
-}
-
-#[panic_handler]
-fn rust_panic(_info: &core::panic::PanicInfo) -> ! {
-    hcf();
-}
-
-fn hcf() -> ! {
-    loop {
-        unsafe {
-            #[cfg(target_arch = "x86_64")]
-            asm!("hlt");
-            #[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
-            asm!("wfi");
-            #[cfg(target_arch = "loongarch64")]
-            asm!("idle 0");
-        }
-    }
+    loop {}
 }

kernel/x86_64-kernel.json

@@ -24,7 +24,8 @@
       "--no-pie",
       "--gc-sections",
       "--build-id=none",
-      "-z", "max-page-size=0x1000"
+      "-z",
+      "max-page-size=0x1000"
     ]
   }
 }

lib/lib_application/Cargo.toml

@@ -1,7 +0,0 @@
-[package]
-name = "lib_application"
-version.workspace = true
-edition.workspace = true
-
-[dependencies]
-lib_ascii = { path = "../lib_ascii" }

lib/lib_application/src/application.rs

@@ -1,10 +0,0 @@
-
-pub trait Application {
-    fn run(&mut self, args: [&'static str; 5]) -> Result<(), Error>;
-}
-
-pub enum Error {
-    OsError(&'static str),
-    ApplicationError(&'static str),
-}
-

lib/lib_application/src/lib.rs

@@ -1,5 +0,0 @@
-#![no_std]
-
-pub mod application;
-pub mod frame;
-pub mod window;

lib/lib_application/src/window.rs

@@ -1,14 +0,0 @@
-
-pub struct Window {
-    width: usize,
-    height: usize
-}
-
-impl Window {
-    pub fn new() -> Self {
-        Self {
-            width: 0,
-            height: 0
-        }
-    }
-}

lib/lib_ascii/Cargo.toml

@@ -1,10 +0,0 @@
-[package]
-name = "lib_ascii"
-version.workspace = true
-edition.workspace = true
-
-[dependencies]
-lazy_static = { version = "1.5.0", default-features = false, features = ["spin_no_std"] }
-lib_framebuffer = { path = "../lib_framebuffer" }
-spin = "0.9.8"
-x86_64 = "0.15.2"

lib/lib_ascii/src/font.rs

@@ -1,203 +0,0 @@
-
-
-
-pub static FONT: [u8; 128 * 16] = [
-    // ASCII 0-31 (Control Characters) - Using simple box patterns
-    // NUL (0)
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-    // SOH (1)
-    0x18, 0x3C, 0x3C, 0x3C, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-    // STX (2)
-    0x18, 0x3C, 0x7E, 0x7E, 0x3C, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-    // ETX (3)
-    0x18, 0x3C, 0x7E, 0xFF, 0xFF, 0x7E, 0x3C, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-    // EOT (4)
-    0x18, 0x3C, 0x7E, 0xFF, 0xFF, 0xFF, 0x7E, 0x3C, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-    // ENQ (5)
-    0x18, 0x3C, 0x7E, 0xFF, 0xFF, 0xFF, 0xFF, 0x7E, 0x3C, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-    // ACK (6)
-    0x18, 0x3C, 0x7E, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7E, 0x3C, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-    // BEL (7)
-    0x18, 0x3C, 0x7E, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7E, 0x3C, 0x18, 0x18, 0x18, 0x18, 0x18,
-    // BS (8)
-    0x18, 0x3C, 0x7E, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7E, 0x3C, 0x18, 0x18, 0x18, 0x18,
-    // HT (9)
-    0x18, 0x3C, 0x7E, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7E, 0x3C, 0x18, 0x18, 0x18,
-    // LF (10)
-    0x18, 0x3C, 0x7E, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7E, 0x3C, 0x18, 0x18,
-    // VT (11)
-    0x18, 0x3C, 0x7E, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7E, 0x3C, 0x18,
-    // FF (12)
-    0x18, 0x3C, 0x7E, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7E, 0x3C,
-    // CR (13)
-    0x3C, 0x7E, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7E,
-    // SO (14)
-    0x7E, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-    // SI (15)
-    0xFF, 0x7E, 0x3C, 0x18, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-    // DLE (16)
-    0xFF, 0xFF, 0x7E, 0x3C, 0x18, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-    // DC1 (17)
-    0xFF, 0xFF, 0xFF, 0x7E, 0x3C, 0x18, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-    // DC2 (18)
-    0xFF, 0xFF, 0xFF, 0xFF, 0x7E, 0x3C, 0x18, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-    // DC3 (19)
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7E, 0x3C, 0x18, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-    // DC4 (20)
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7E, 0x3C, 0x18, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-    // NAK (21)
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7E, 0x3C, 0x18, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-    // SYN (22)
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7E, 0x3C, 0x18, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-    // ETB (23)
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7E, 0x3C, 0x18, 0xFF, 0xFF, 0xFF, 0xFF,
-    // CAN (24)
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7E, 0x3C, 0x18, 0xFF, 0xFF, 0xFF,
-    // EM (25)
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7E, 0x3C, 0x18, 0xFF, 0xFF,
-    // SUB (26)
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7E, 0x3C, 0x18, 0xFF,
-    // ESC (27)
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7E, 0x3C, 0x18,
-    // FS (28)
-    0x18, 0x3C, 0x7E, 0xFF, 0x18, 0x18, 0x18, 0x18, 0x18, 0xFF, 0x7E, 0x3C, 0x18, 0x18, 0x18, 0x18,
-    // GS (29)
-    0x18, 0x3C, 0x7E, 0xFF, 0xFF, 0x18, 0x18, 0x18, 0xFF, 0x7E, 0x3C, 0x18, 0x18, 0x18, 0x18, 0x18,
-    // RS (30)
-    0x18, 0x3C, 0x7E, 0xFF, 0xFF, 0xFF, 0x18, 0xFF, 0x7E, 0x3C, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-    // US (31)
-    0x18, 0x3C, 0x7E, 0xFF, 0xFF, 0xFF, 0xFF, 0x7E, 0x3C, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-    // Space (32)
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    // ! (33)
-    0x00, 0x00, 0x18, 0x3C, 0x3C, 0x3C, 0x18, 0x18, 0x18, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00,
-    // " (34)
-    0x00, 0x66, 0x66, 0x66, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    // # (35)
-    0x00, 0x00, 0x00, 0x6C, 0x6C, 0xFE, 0x6C, 0x6C, 0x6C, 0xFE, 0x6C, 0x6C, 0x00, 0x00, 0x00, 0x00,
-    // $ (36)
-    0x18, 0x18, 0x7C, 0xC6, 0xC2, 0xC0, 0x7C, 0x06, 0x86, 0xC6, 0x7C, 0x18, 0x18, 0x00, 0x00, 0x00,
-    // % (37)
-    0x00, 0x00, 0x00, 0x00, 0xC2, 0xC6, 0x0C, 0x18, 0x30, 0x60, 0xC6, 0x86, 0x00, 0x00, 0x00, 0x00,
-    // & (38)
-    0x00, 0x00, 0x38, 0x6C, 0x6C, 0x38, 0x76, 0xDC, 0xCC, 0xCC, 0x76, 0x00, 0x00, 0x00, 0x00, 0x00,
-    // ' (39)
-    0x00, 0x30, 0x30, 0x30, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    // ( (40)
-    0x00, 0x00, 0x0C, 0x18, 0x30, 0x30, 0x30, 0x30, 0x30, 0x18, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00,
-    // ) (41)
-    0x00, 0x00, 0x30, 0x18, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x18, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00,
-    // * (42)
-    0x00, 0x00, 0x00, 0x00, 0x66, 0x3C, 0xFF, 0x3C, 0x66, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    // + (43)
-    0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x7E, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    // , (44)
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x30, 0x00, 0x00, 0x00, 0x00,
-    // - (45)
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    // . (46)
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00,
-    // / (47)
-    0x00, 0x00, 0x00, 0x00, 0x02, 0x06, 0x0C, 0x18, 0x30, 0x60, 0xC0, 0x80, 0x00, 0x00, 0x00, 0x00,
-    // 0-9 (48-57)
-    0x00, 0x00, 0x38, 0x6C, 0xC6, 0xC6, 0xD6, 0xD6, 0xC6, 0xC6, 0x6C, 0x38, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x18, 0x38, 0x78, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x7E, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x7C, 0xC6, 0x06, 0x0C, 0x18, 0x30, 0x60, 0xC0, 0xC6, 0xFE, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x7C, 0xC6, 0x06, 0x06, 0x3C, 0x06, 0x06, 0x06, 0xC6, 0x7C, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x0C, 0x1C, 0x3C, 0x6C, 0xCC, 0xFE, 0x0C, 0x0C, 0x0C, 0x1E, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0xFE, 0xC0, 0xC0, 0xC0, 0xFC, 0x06, 0x06, 0x06, 0xC6, 0x7C, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x38, 0x60, 0xC0, 0xC0, 0xFC, 0xC6, 0xC6, 0xC6, 0xC6, 0x7C, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0xFE, 0xC6, 0x06, 0x06, 0x0C, 0x18, 0x30, 0x30, 0x30, 0x30, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x7C, 0xC6, 0xC6, 0xC6, 0x7C, 0xC6, 0xC6, 0xC6, 0xC6, 0x7C, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x7C, 0xC6, 0xC6, 0xC6, 0x7E, 0x06, 0x06, 0x06, 0x0C, 0x78, 0x00, 0x00, 0x00, 0x00,
-    // : (58)
-    0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00,
-    // ; (59)
-    0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x18, 0x18, 0x30, 0x00, 0x00, 0x00, 0x00,
-    // < (60)
-    0x00, 0x00, 0x00, 0x06, 0x0C, 0x18, 0x30, 0x60, 0x30, 0x18, 0x0C, 0x06, 0x00, 0x00, 0x00, 0x00,
-    // = (61)
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x00, 0x00, 0x7E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    // > (62)
-    0x00, 0x00, 0x00, 0x60, 0x30, 0x18, 0x0C, 0x06, 0x0C, 0x18, 0x30, 0x60, 0x00, 0x00, 0x00, 0x00,
-    // ? (63)
-    0x00, 0x00, 0x7C, 0xC6, 0xC6, 0x0C, 0x18, 0x18, 0x18, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00,
-    // @ (64)
-    0x00, 0x00, 0x00, 0x7C, 0xC6, 0xC6, 0xDE, 0xDE, 0xDE, 0xDC, 0xC0, 0x7C, 0x00, 0x00, 0x00, 0x00,
-    // A-Z (65-90)
-    0x00, 0x00, 0x10, 0x38, 0x6C, 0xC6, 0xC6, 0xFE, 0xC6, 0xC6, 0xC6, 0xC6, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0xFC, 0x66, 0x66, 0x66, 0x7C, 0x66, 0x66, 0x66, 0x66, 0xFC, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x3C, 0x66, 0xC2, 0xC0, 0xC0, 0xC0, 0xC0, 0xC2, 0x66, 0x3C, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0xF8, 0x6C, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x6C, 0xF8, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0xFE, 0x66, 0x62, 0x68, 0x78, 0x68, 0x60, 0x62, 0x66, 0xFE, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0xFE, 0x66, 0x62, 0x68, 0x78, 0x68, 0x60, 0x60, 0x60, 0xF0, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x3C, 0x66, 0xC2, 0xC0, 0xC0, 0xDE, 0xC6, 0xC6, 0x66, 0x3A, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0xC6, 0xC6, 0xC6, 0xC6, 0xFE, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x3C, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3C, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x1E, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0xCC, 0xCC, 0xCC, 0x78, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0xE6, 0x66, 0x6C, 0x6C, 0x78, 0x78, 0x6C, 0x66, 0x66, 0xE6, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0xF0, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x62, 0x66, 0xFE, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0xC6, 0xEE, 0xFE, 0xFE, 0xD6, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0xC6, 0xE6, 0xF6, 0xFE, 0xDE, 0xCE, 0xC6, 0xC6, 0xC6, 0xC6, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x38, 0x6C, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0x6C, 0x38, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0xFC, 0x66, 0x66, 0x66, 0x7C, 0x60, 0x60, 0x60, 0x60, 0xF0, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x7C, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xD6, 0xDE, 0x7C, 0x0C, 0x0E, 0x00, 0x00,
-    0x00, 0x00, 0xFC, 0x66, 0x66, 0x66, 0x7C, 0x6C, 0x66, 0x66, 0x66, 0xE6, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x7C, 0xC6, 0xC6, 0x60, 0x38, 0x0C, 0x06, 0xC6, 0xC6, 0x7C, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x7E, 0x7E, 0x5A, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3C, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0x7C, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0x6C, 0x38, 0x10, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0xC6, 0xC6, 0xC6, 0xC6, 0xD6, 0xD6, 0xD6, 0xFE, 0xEE, 0x6C, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0xC6, 0xC6, 0x6C, 0x7C, 0x38, 0x38, 0x7C, 0x6C, 0xC6, 0xC6, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x66, 0x66, 0x66, 0x66, 0x3C, 0x18, 0x18, 0x18, 0x18, 0x3C, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0xFE, 0xC6, 0x86, 0x0C, 0x18, 0x30, 0x60, 0xC2, 0xC6, 0xFE, 0x00, 0x00, 0x00, 0x00,
-    // [ (91)
-    0x00, 0x00, 0x3C, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x3C, 0x00, 0x00, 0x00, 0x00,
-    // \ (92)
-    0x00, 0x00, 0x00, 0x80, 0xC0, 0xE0, 0x70, 0x38, 0x1C, 0x0E, 0x06, 0x02, 0x00, 0x00, 0x00, 0x00,
-    // ] (93)
-    0x00, 0x00, 0x3C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x3C, 0x00, 0x00, 0x00, 0x00,
-    // ^ (94)
-    0x10, 0x38, 0x6C, 0xC6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    // _ (95)
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00,
-    // ` (96)
-    0x30, 0x18, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    // a-z (97-122) - lowercase letters
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x0C, 0x7C, 0xCC, 0xCC, 0xCC, 0x76, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0xE0, 0x60, 0x60, 0x78, 0x6C, 0x66, 0x66, 0x66, 0x66, 0x7C, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x7C, 0xC6, 0xC0, 0xC0, 0xC0, 0xC6, 0x7C, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x1C, 0x0C, 0x0C, 0x3C, 0x6C, 0xCC, 0xCC, 0xCC, 0xCC, 0x76, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x7C, 0xC6, 0xFE, 0xC0, 0xC0, 0xC6, 0x7C, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x38, 0x6C, 0x64, 0x60, 0xF0, 0x60, 0x60, 0x60, 0x60, 0xF0, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0xCC, 0xCC, 0xCC, 0x7C, 0x0C, 0xCC, 0x78, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0xE0, 0x60, 0x60, 0x6C, 0x76, 0x66, 0x66, 0x66, 0x66, 0xE6, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x18, 0x18, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3C, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x06, 0x06, 0x00, 0x0E, 0x06, 0x06, 0x06, 0x06, 0x66, 0x66, 0x3C, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0xE0, 0x60, 0x60, 0x66, 0x6C, 0x78, 0x78, 0x6C, 0x66, 0xE6, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3C, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0xEC, 0xFE, 0xD6, 0xD6, 0xD6, 0xD6, 0xC6, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0xDC, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x7C, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0x7C, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0xDC, 0x66, 0x66, 0x66, 0x7C, 0x60, 0x60, 0xF0, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0xCC, 0xCC, 0xCC, 0x7C, 0x0C, 0x0C, 0x1E, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0xDC, 0x76, 0x66, 0x60, 0x60, 0x60, 0xF0, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x7C, 0xC6, 0x60, 0x38, 0x0C, 0xC6, 0x7C, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x10, 0x30, 0x30, 0xFC, 0x30, 0x30, 0x30, 0x30, 0x36, 0x1C, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x76, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3C, 0x18, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0xC6, 0xC6, 0xC6, 0xD6, 0xD6, 0xFE, 0x6C, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0xC6, 0x6C, 0x38, 0x38, 0x38, 0x6C, 0xC6, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0xC6, 0xC6, 0xC6, 0xC6, 0x7E, 0x06, 0xC6, 0x7C, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0xCC, 0x18, 0x30, 0x60, 0xC6, 0xFE, 0x00, 0x00, 0x00, 0x00,
-    // { (123)
-    0x00, 0x00, 0x0E, 0x18, 0x18, 0x18, 0x70, 0x18, 0x18, 0x18, 0x18, 0x0E, 0x00, 0x00, 0x00, 0x00,
-    // | (124)
-    0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00,
-    // } (125)
-    0x00, 0x00, 0x70, 0x18, 0x18, 0x18, 0x0E, 0x18, 0x18, 0x18, 0x18, 0x70, 0x00, 0x00, 0x00, 0x00,
-    // ~ (126)
-    0x00, 0x00, 0x76, 0xDC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    // DEL (127)
-    0x00, 0x00, 0x00, 0x00, 0x10, 0x38, 0x6C, 0xC6, 0xC6, 0xC6, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00,
-];

lib/lib_ascii/src/lib.rs

@@ -1,201 +0,0 @@
-#![no_std]
-
-use core::fmt;
-use lazy_static::lazy_static;
-use spin::{Lazy, Mutex};
-use x86_64::instructions::interrupts;
-
-use lib_framebuffer::{FRAMEBUFFER_WRITER, Color};
-
-mod font;
-use font::FONT;
-
-static FONT_WIDTH: u32 = 8;
-static FONT_HEIGHT: u32 = 16;
-
-pub static WRITER: Lazy<Mutex<Writer>> = Lazy::new(|| Mutex::new(Writer::new()));
-
-
-
-pub fn screensize_chars() -> (u32, u32) {
-    let writer = WRITER.lock();
-    (writer.screen_width, writer.screen_height)
-}
-
-pub struct Writer {
-    // these are measured in chars NOT pixels
-    screen_width: u32,
-    screen_height: u32,
-
-    text_line: u32, // 16 pixels tall
-    text_col: u32,  // 8 pixels wide
-
-    fg_color: u32,
-    bg_color: u32
-}
-
-impl Writer {
-
-    pub fn new() -> Self {
-        if let Some(writer) = FRAMEBUFFER_WRITER.lock().as_mut() {
-            Self {
-                screen_width: writer.width() as u32 / 8,
-                screen_height: writer.height() as u32 / 16,
-                text_line: 0,
-                text_col: 0,
-                fg_color: 0xFFFFFF,
-                bg_color: 0x000000
-            }
-        } else {
-            panic!("Framebuffer writer not initialized");
-        }
-    }
-
-    pub fn write_char(&mut self, mut c: u8) {
-        if c == b'\n' {
-            self.newline();
-            return;
-        }
-
-        if c < 32 || c > 126 {
-            c = '?' as u8;
-        }
-
-        // 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];
-
-        if let Some(writer) = FRAMEBUFFER_WRITER.lock().as_mut() {
-            for row in 0..16 {
-                let line: u8 = data[row];
-                for col in 0..8 {
-                    let pixel_x: u32 = self.text_col * FONT_WIDTH + col;
-                    let pixel_y: u32 = self.text_line * FONT_HEIGHT + row as u32;
-    
-                    if line & (0x80 >> col) != 0 {
-                        // write the foreground color
-                        writer.write_pixel(pixel_x as usize, pixel_y as usize, Color::RGB(255, 0, 0));
-                    } else {
-                        // write the background color
-                        writer.write_pixel(pixel_x as usize, pixel_y as usize, Color::HexARGB(self.bg_color));
-                    }
-                }
-            }
-        }   
-
-        // go to next position
-        if self.text_col + 1 >= self.screen_width {
-            self.newline();
-        } else {
-            self.text_col += 1;
-        }
-    }
-
-    pub fn dimensions(&self) -> (u32, u32) {
-        (self.screen_width, self.screen_height)
-    }
-
-    pub fn next_char(&mut self) {
-        self.text_col += 1;
-    }
-
-    pub fn newline(&mut self) {
-        self.text_col = 0;
-
-        if self.text_line + 1 >= self.screen_height {
-            self.text_line = 0;
-        } else {
-            self.text_line += 1;
-        }
-    }
-
-    pub fn write_string(&mut self, s: &str) {
-        for c in s.chars() {
-            self.write_char(c as u8);
-        }
-    }
-
-    pub fn set_colour(&mut self, col: (u32, u32)) {
-        self.fg_color = col.0;
-        self.bg_color = col.1;
-    }
-
-    pub fn reset_colour(&mut self) {
-        self.fg_color = 0xFFFFFF;
-        self.bg_color = 0x000000;
-    }
-}
-
-impl core::fmt::Write for Writer {
-    fn write_str(&mut self, s: &str) -> core::fmt::Result {
-        self.write_string(s);
-        Ok(())
-    }
-}
-
-fn write(args: fmt::Arguments, fg_color: u32, bg_color: u32) {
-    use core::fmt::Write;
-
-    interrupts::without_interrupts(|| {
-        let mut writer = WRITER.lock();
-        writer.set_colour((fg_color, bg_color));
-        writer.write_fmt(args).unwrap();
-        writer.reset_colour();
-    });
-}
-
-pub fn _print(args: fmt::Arguments) {
-    write(args, 0xFFFFFF, 0x000000);
-}
-
-pub fn _printerr(args: fmt::Arguments) {
-    write(args, 0xFF8080, 0x000000);
-}
-
-pub fn _log(args: fmt::Arguments) {
-    write(args, 0xFFFF00, 0x000000);
-}
-
-pub fn clear_screen() {
-    interrupts::without_interrupts(|| {
-        let mut writer = WRITER.lock();
-        writer.text_line = 0;
-        writer.text_col = 0;
-    
-        if let Some(writer) = FRAMEBUFFER_WRITER.lock().as_mut() {
-            writer.clear();
-        }
-    });    
-}
-
-#[macro_export]
-macro_rules! println_log {
-	() => ($crate::print_log!("\n"));
-	($($arg:tt)*) => ($crate::print_log!("{}\n", format_args!($($arg)*)));
-}
-
-#[macro_export]
-macro_rules! print_log {
-	($($arg:tt)*) => ($crate::_log(format_args!($($arg)*)));
-}
-
-#[macro_export]
-macro_rules! println {
-	() => ($crate::print!("\n"));
-	($($arg:tt)*) => ($crate::print!("{}\n", format_args!($($arg)*)));
-}
-
-#[macro_export]
-macro_rules! print {
-	($($arg:tt)*) => ($crate::_print(format_args!($($arg)*)));
-}
-
-#[macro_export]
-macro_rules! printlnerr {
-    () => ($crate::printerr!("\n"));
-    ($($arg:tt)*) => ($crate::printerr!("{}\n", format_args!($($arg)*)));
-}
-
-#[macro_export]
-macro_rules! printerr {
-    ($($arg:tt)*) => ($crate::_printerr(format_args!($($arg)*)));
-}

lib/lib_framebuffer/Cargo.toml

@@ -1,8 +0,0 @@
-[package]
-name = "lib_framebuffer"
-version.workspace = true
-edition.workspace = true
-
-[dependencies]
-limine = "0.3.1"
-spin = "0.9.8"

lib/lib_framebuffer/src/colour.rs

@@ -1,51 +0,0 @@
-#[repr(u32)]
-#[derive(Copy, Clone, PartialEq, Eq, Debug)]
-pub enum Color {
-    ARGB(u8, u8, u8, u8),
-    RGB(u8, u8, u8),
-    HexARGB(u32),
-    Black = 0x000000FF,
-    Blue = 0x0000FFFF,
-    Green = 0x00FF00FF,
-    Cyan = 0x00FFFFFF,
-    Red = 0xFF0000FF,
-    Magenta = 0xFF00FFFF,
-    Yellow = 0xFFFF00FF,
-    White = 0xFFFFFFFF,
-}
-
-impl Into<u32> for Color {
-    fn into(self) -> u32 {
-        match self {
-            Color::ARGB(a, r, g, b) => (a as u32) << 24 | (r as u32) << 16 | (g as u32) << 8 | (b as u32),
-            Color::RGB(r, g, b) => (0u32) << 24 | (r as u32) << 16 | (g as u32) << 8 | (b as u32),
-            Color::HexARGB(hex) => hex,
-            Color::Black => 0xFF000000,
-            Color::Blue => 0xFF0000FF, 
-            Color::Green => 0xFF00FF00, 
-            Color::Cyan => 0xFF00FFFF,
-            Color::Red => 0xFFFF0000,   
-            Color::Magenta => 0xFFFF00FF, 
-            Color::Yellow => 0xFFFFFF00, 
-            Color::White => 0xFFFFFFFF, 
-        }
-    }
-}
-
-impl core::fmt::Display for Color {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        match self {
-            Color::ARGB(r, g, b, a) => write!(f, "RGBA(#{:x}{:x}{:x}{:x})", r, g, b, a),
-            Color::RGB(r, g, b) => write!(f, "RGB(#{:x}{:x}{:x})", r, g, b),
-            Color::HexARGB(hex) => write!(f, "Hex(#{:x})", hex),
-            Color::Black => write!(f, "Black"),
-            Color::Blue => write!(f, "Blue"),
-            Color::Green => write!(f, "Green"),
-            Color::Cyan => write!(f, "Cyan"),
-            Color::Red => write!(f, "Red"),
-            Color::Magenta => write!(f, "Magenta"),
-            Color::Yellow => write!(f, "Yellow"),
-            Color::White => write!(f, "White"),
-        }
-    }
-}

lib/lib_framebuffer/src/framebuffer.rs

@@ -1,67 +0,0 @@
-use core::panic;
-use limine::framebuffer::Framebuffer;
-use spin::{Mutex, Lazy};
-
-use crate::{colour::Color, FRAMEBUFFER_REQUEST};
-
-pub static FRAMEBUFFER_WRITER: Lazy<Mutex<Option<FramebufferWriter>>> = Lazy::new(|| Mutex::new(
-    if let Some(framebuffer_response) = FRAMEBUFFER_REQUEST.get_response() {
-        let framebuffer = framebuffer_response.framebuffers().next().unwrap();
-        Some(FramebufferWriter::new(framebuffer))
-    } else {
-        panic!("Framebuffer request failed");
-    }
-));
-
-
-
-pub struct FramebufferWriter<'a> {
-    framebuffer: Framebuffer<'a>,
-}
-
-unsafe impl<'a> Send for FramebufferWriter<'a> {}
-unsafe impl<'a> Sync for FramebufferWriter<'a> {}
-impl<'a> FramebufferWriter<'a> {
-    pub fn new(framebuffer: Framebuffer<'a>) -> Self {
-        Self {
-            framebuffer,
-        }
-    }
-
-    pub fn write_pixel(&self, x: usize, y: usize, color: Color) {
-        let pitch = self.framebuffer.pitch() as usize;
-        let bpp = (self.framebuffer.bpp() / 8) as usize;
-        let pixel_offset = y * pitch + x * bpp;
-
-        unsafe {
-            *(self.framebuffer.addr().add(pixel_offset) as *mut u32) = color.into();
-        }
-    }
-
-    pub fn render_frame(&self, buffer: &[Color; 1280 * 800]) {
-        for (y, row) in buffer.chunks(1280).enumerate() {
-            for (x, pixel) in row.iter().enumerate() {
-                self.write_pixel(x, y, *pixel);
-            }
-        }
-    }
-
-    pub fn width(&self) -> u32 {
-        self.framebuffer.width() as u32
-    }
-
-    pub fn height(&self) -> u32 {
-        self.framebuffer.height() as u32
-    }
-
-    pub fn clear(&self) {
-        let width = self.framebuffer.width() as usize;
-        let height = self.framebuffer.height() as usize;
-
-        for y in 0..height {
-            for x in 0..width {
-                self.write_pixel(x, y, Color::Black);
-            }
-        }
-    }
-}

lib/lib_framebuffer/src/lib.rs

@@ -1,20 +0,0 @@
-#![no_std]
-
-use limine::request::FramebufferRequest;
-
-#[used]
-#[link_section = ".requests"]
-static FRAMEBUFFER_REQUEST: FramebufferRequest = FramebufferRequest::new();
-
-mod framebuffer;
-mod colour;
-pub use framebuffer::FRAMEBUFFER_WRITER;
-pub use colour::Color;
-
-pub fn screensize_px() -> (u32, u32) {
-    if let Some(writer) = FRAMEBUFFER_WRITER.lock().as_mut() {
-        (writer.width(), writer.height())
-    } else {
-        (0, 0)
-    }
-}

lib/lib_serial/Cargo.toml

@@ -1,10 +0,0 @@
-[package]
-name = "lib_serial"
-version.workspace = true
-edition.workspace = true
-
-[dependencies]
-lazy_static = { version = "1.5.0", default-features = false, features = ["spin_no_std"] }
-spin = "0.9.8"
-x86_64 = "0.15.2"
-

lib/lib_serial/src/io.rs

@@ -1,23 +0,0 @@
-use core::arch::asm;
-
-#[inline]
-pub unsafe fn inb(port: u16) -> u8 {
-    let value: u8;
-    asm!(
-        "in al, dx",
-        out("al") value,
-        in("dx") port,
-        options(nomem, nostack, preserves_flags)
-    );
-    value
-}
-
-#[inline]
-pub unsafe fn outb(port: u16, value: u8) {
-    asm!(
-        "out dx, al",
-        in("dx") port,
-        in("al") value,
-        options(nomem, nostack, preserves_flags)
-    );
-}

lib/lib_serial/src/lib.rs

@@ -1,157 +0,0 @@
-#![no_std]
-
-use core::{fmt, sync::atomic::{AtomicUsize, Ordering}};
-use spin::Mutex;
-use lazy_static::lazy_static;
-
-mod io;
-use io::*;
-use x86_64::instructions::interrupts;
-
-static PORT: u16 = 0x3f8;
-static mut BUFFER: [u8; 256] = [0; 256];
-static BUFFER_LEN: AtomicUsize = AtomicUsize::new(0);
-
-lazy_static!{
-    static ref READER: Mutex<Option<Reader>> = Mutex::new(None);
-    static ref WRITER: Mutex<Option<Writer>> = Mutex::new(None);
-}
-
-struct Reader;
-
-struct Writer;
-
-impl fmt::Write for Writer {
-    fn write_str(&mut self, s: &str) -> fmt::Result {
-        for c in s.chars() {
-            self.write_byte(c as u8);
-        }
-        Ok(())
-    }
-}
-
-impl Writer {
-    unsafe fn write_success(&self) -> bool {
-        inb(PORT + 5) & 0x20 != 0
-    }
-
-    pub fn write_byte(&self, data: u8) { unsafe {
-        while !self.write_success() {};
-        outb(PORT + 0, data);
-    }}
-}
-
-
-pub fn init() -> Result<(), &'static str> {
-    if let Err(e) = test() {
-        return Err(e);
-    }
-
-    if READER.lock().is_none() {
-        *READER.lock() = Some(Reader);
-    }
-
-    if WRITER.lock().is_none() {
-        *WRITER.lock() = Some(Writer);
-    }
-
-    Ok(())
-}
-
-pub fn test() -> Result<(), &'static str> {
-    unsafe {
-        outb(PORT + 1, 0x00);    // Disable all interrupts
-        outb(PORT + 3, 0x80);    // Enable DLAB (set baud rate divisor)
-        outb(PORT + 0, 0x03);    // Set divisor to 3 (lo byte) 38400 baud
-        outb(PORT + 1, 0x00);    //                  (hi byte)
-        outb(PORT + 3, 0x03);    // 8 bits, no parity, one stop bit
-        outb(PORT + 2, 0xC7);    // Enable FIFO, clear them, with 14-bytethreshold
-        outb(PORT + 4, 0x0B);    // IRQs enabled, RTS/DSR set
-        outb(PORT + 4, 0x1E);    // Set in loopback mode, test the serial chip
-        outb(PORT + 0, 0xAE);    // Test serial chip (send byte 0xAE and check if serial returns same byte)
-
-        if inb(PORT + 0)  != 0xAE {
-            return Err("serial test failed")
-        }
-
-        outb(PORT + 4, 0x0F);
-    }
-
-    Ok(())
-}
-
-impl Reader {
-    pub fn read_str_to_buffer(&mut self) { unsafe {
-        while !self.read_ready() {};
-
-        BUFFER_LEN.store(0, Ordering::SeqCst);
-
-        while BUFFER_LEN.load(Ordering::SeqCst) < 256 {
-            let c = self.read();
-            BUFFER[BUFFER_LEN.load(Ordering::SeqCst)] = c;
-            if c as char == '\r' {
-                break;
-            }
-            BUFFER_LEN.fetch_add(1, Ordering::SeqCst);
-        }
-
-        serial_println!("returning")
-    }}
-
-    unsafe fn read_ready(&self) -> bool {
-        inb(PORT + 5) & 1 != 0
-    }
-
-    pub fn read(&self) -> u8 { unsafe {
-        while !self.read_ready() {};
-        return inb(PORT + 0);
-    }}
-}
-
-pub fn _serial_write(args: fmt::Arguments) {
-    use core::fmt::Write;
-
-    interrupts::without_interrupts(|| {
-        if let Some(writer) = WRITER.lock().as_mut() {
-            writer.write_fmt(args).unwrap();
-        }
-    })    
-}
-
-#[macro_export]
-macro_rules! serial_println {
-    () => ($crate::serial_print!("\n"));
-    ($($arg:tt)*) => ($crate::serial_print!("{}\n", format_args!($($arg)*)));
-}
-
-#[macro_export]
-macro_rules! serial_print {
-    ($($arg:tt)*) => ($crate::_serial_write(format_args!($($arg)*)));
-}
-
-pub fn serial_read() -> &'static str {
-    serial_println!("getting value!");
-
-    interrupts::without_interrupts(|| {
-        if let Some(reader) = READER.lock().as_mut() {
-            serial_println!("stuff happnin.");
-            reader.read_str_to_buffer();
-        } else {
-            serial_println!("failed to get writer");
-        }
-    });
-
-    serial_println!("eee");
-
-    let i = BUFFER_LEN.load(Ordering::SeqCst);
-
-    return unsafe {
-        if i != 0 {
-            core::str::from_utf8(&BUFFER[..i - 1]).unwrap()
-        } else { 
-            serial_println!("empty string");
-            ""
-        }
-    }
-}
-

scripts/run.sh

@@ -85,7 +85,7 @@ mkdir -p "$iso_root/EFI/BOOT"
 if [ ! -d "$build_dir/limine" ]; then
     compiling "limine bootloader"
     cd "$build_dir"
-    git clone https://github.com/limine-bootloader/limine.git --branch=v8.x-binary --depth=1 "$build_dir/limine" || error "failed to clone limine"
+    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