omfg it's fixed 🙏

let's just use strings for now
please bugs begone
2024-09-16 21:56:52 +01:00 · 2024-09-16 20:45:19 +01:00 · 2024-09-16 20:15:51 +01:00 · 2024-09-15 17:01:29 +01:00
20 changed files with 194 additions and 228 deletions
--- a/Cargo.lock
+++ b/Cargo.lock
@ -61,9 +61,9 @@ dependencies = [

 [[package]]
 name = "anyhow"
-version = "1.0.88"
+version = "1.0.89"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e1496f8fb1fbf272686b8d37f523dab3e4a7443300055e74cdaa449f3114356"
+checksum = "86fdf8605db99b54d3cd748a44c6d04df638eb5dafb219b135d0149bd0db01f6"

 [[package]]
 name = "autocfg"
@ -148,9 +148,9 @@ checksum = "8318a53db07bb3f8dca91a600466bdb3f2eaadeedfdbcf02e1accbad9271ba50"

 [[package]]
 name = "cc"
-version = "1.1.18"
+version = "1.1.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b62ac837cdb5cb22e10a256099b4fc502b1dfe560cb282963a974d7abd80e476"
+checksum = "2d74707dde2ba56f86ae90effb3b43ddd369504387e718014de010cec7959800"
 dependencies = [
 "shlex",
 ]
@ -390,17 +390,17 @@ dependencies = [
 [[package]]
 name = "hbbytecode"
 version = "0.1.0"
-source = "git+https://git.ablecorp.us/AbleOS/holey-bytes.git#c133c2dbe71b3f1e1142bacef200775ae0c1d22d"
+source = "git+https://git.ablecorp.us/AbleOS/holey-bytes.git#254d5ed96234c8291770d84b2ac11ef7dd403b28"

 [[package]]
 name = "hbbytecode"
 version = "0.1.0"
-source = "git+https://git.ablecorp.us/ableos/holey-bytes#c133c2dbe71b3f1e1142bacef200775ae0c1d22d"
+source = "git+https://git.ablecorp.us/ableos/holey-bytes.git#254d5ed96234c8291770d84b2ac11ef7dd403b28"

 [[package]]
 name = "hblang"
 version = "0.1.0"
-source = "git+https://git.ablecorp.us/AbleOS/holey-bytes.git#c133c2dbe71b3f1e1142bacef200775ae0c1d22d"
+source = "git+https://git.ablecorp.us/AbleOS/holey-bytes.git#254d5ed96234c8291770d84b2ac11ef7dd403b28"
 dependencies = [
 "hbvm 0.1.0 (git+https://git.ablecorp.us/AbleOS/holey-bytes.git)",
 ]
@ -408,7 +408,7 @@ dependencies = [
 [[package]]
 name = "hbvm"
 version = "0.1.0"
-source = "git+https://git.ablecorp.us/AbleOS/holey-bytes.git#c133c2dbe71b3f1e1142bacef200775ae0c1d22d"
+source = "git+https://git.ablecorp.us/AbleOS/holey-bytes.git#254d5ed96234c8291770d84b2ac11ef7dd403b28"
 dependencies = [
 "hbbytecode 0.1.0 (git+https://git.ablecorp.us/AbleOS/holey-bytes.git)",
 ]
@ -416,9 +416,9 @@ dependencies = [
 [[package]]
 name = "hbvm"
 version = "0.1.0"
-source = "git+https://git.ablecorp.us/ableos/holey-bytes#c133c2dbe71b3f1e1142bacef200775ae0c1d22d"
+source = "git+https://git.ablecorp.us/ableos/holey-bytes.git#254d5ed96234c8291770d84b2ac11ef7dd403b28"
 dependencies = [
- "hbbytecode 0.1.0 (git+https://git.ablecorp.us/ableos/holey-bytes)",
+ "hbbytecode 0.1.0 (git+https://git.ablecorp.us/ableos/holey-bytes.git)",
 ]

 [[package]]
@ -526,9 +526,9 @@ dependencies = [

 [[package]]
 name = "iana-time-zone"
-version = "0.1.60"
+version = "0.1.61"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e7ffbb5a1b541ea2561f8c41c087286cc091e21e556a4f09a8f6cbf17b69b141"
+checksum = "235e081f3925a06703c2d0117ea8b91f042756fd6e7a6e5d901e8ca1a996b220"
 dependencies = [
 "android_system_properties",
 "core-foundation-sys",
@ -597,7 +597,7 @@ dependencies = [
 "derive_more",
 "embedded-graphics",
 "hashbrown",
- "hbvm 0.1.0 (git+https://git.ablecorp.us/ableos/holey-bytes)",
+ "hbvm 0.1.0 (git+https://git.ablecorp.us/ableos/holey-bytes.git)",
 "limine",
 "log",
 "sbi",
@ -737,9 +737,9 @@ dependencies = [

 [[package]]
 name = "once_cell"
-version = "1.20.0"
+version = "1.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "33ea5043e58958ee56f3e15a90aee535795cd7dfd319846288d93c5b57d85cbe"
+checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"

 [[package]]
 name = "paste"
--- a/kernel/Cargo.toml
+++ b/kernel/Cargo.toml
@ -6,7 +6,7 @@ version = "0.2.0"

 [dependencies]
 embedded-graphics = "0.8"
-hbvm.git = "https://git.ablecorp.us/ableos/holey-bytes"
+hbvm.git = "https://git.ablecorp.us/ableos/holey-bytes.git"
 log = "0.4"
 spin = "0.9"
 slab = { version = "0.4", default-features = false }
--- a/kernel/src/arch/x86_64/gdt.rs
+++ b/kernel/src/arch/x86_64/gdt.rs
@ -12,7 +12,7 @@ use {
 pub const DOUBLE_FAULT_IX: u16 = 0;

 const STACK_SIZE: usize = 5 * 1024;
-const STACK_ALIGNMENT: usize = 4096;
+const STACK_ALIGNMENT: usize = 1;

 pub unsafe fn init() {
    use x86_64::instructions::{
@ -39,7 +39,7 @@ static TSS: Lazy<TaskStateSegment> = Lazy::new(|| {
    let stack_ptr = unsafe {
        let layout = alloc::alloc::Layout::from_size_align(STACK_SIZE, STACK_ALIGNMENT)
            .expect("Failed to create stack layout");
-        let stack = alloc::alloc::alloc_zeroed(layout);
+        let stack = alloc::alloc::alloc(layout);
        VirtAddr::from_ptr(stack) + STACK_SIZE as u64
    };

--- a/kernel/src/arch/x86_64/interrupts.rs
+++ b/kernel/src/arch/x86_64/interrupts.rs
@ -1,56 +1,52 @@
-// TODO: Turn apic keyboard interrupt into a standard ipc message
 use {
+    core::mem::MaybeUninit,
    log::trace,
-    spin::{Lazy, Mutex},
    x2apic::lapic::{LocalApic, LocalApicBuilder},
    x86_64::structures::idt::{InterruptDescriptorTable, InterruptStackFrame, PageFaultErrorCode},
 };

-pub unsafe fn init() {
-    trace!("Initialising IDT");
-    IDT.load();
-    Lazy::force(&LAPIC);
-    x86_64::instructions::interrupts::enable();
-}
+/// Safety: Using LAPIC or IDT before init() is UB
+/// Using
+static mut LAPIC: LocalApic = unsafe { MaybeUninit::zeroed().assume_init() };
+static mut IDT: InterruptDescriptorTable = unsafe { MaybeUninit::zeroed().assume_init() };

 #[repr(u8)]
 enum Interrupt {
    Timer = 32,
-
    ApicErr = u8::MAX - 1,
    Spurious = u8::MAX,
 }

-pub(crate) static LAPIC: Lazy<Mutex<LocalApic>> = Lazy::new(|| {
-    let mut lapic = LocalApicBuilder::new()
+pub unsafe fn init() {
+    trace!("Initializing IDT and LAPIC");
+
+    // Initialize and load the IDT
+    IDT = InterruptDescriptorTable::new();
+    IDT.double_fault
+        .set_handler_fn(double_fault)
+        .set_stack_index(super::gdt::DOUBLE_FAULT_IX);
+    IDT.page_fault.set_handler_fn(page_fault);
+
+    IDT[Interrupt::ApicErr as u8].set_handler_fn(apic_err);
+    IDT[Interrupt::Spurious as u8].set_handler_fn(spurious);
+    IDT[Interrupt::Timer as u8].set_handler_fn(timer);
+
+    IDT.load();
+
+    LAPIC = LocalApicBuilder::new()
        .timer_vector(Interrupt::Timer as usize)
        .error_vector(Interrupt::ApicErr as usize)
        .spurious_vector(Interrupt::Spurious as usize)
        .set_xapic_base(
-            unsafe { x2apic::lapic::xapic_base() }
+            x2apic::lapic::xapic_base()
                + super::memory::HHDM_OFFSET.load(core::sync::atomic::Ordering::Relaxed),
        )
        .build()
-        .expect("failed to setup Local APIC");
-    unsafe { lapic.enable() };
-    Mutex::new(lapic)
-});
+        .expect("Failed to setup Local APIC");
+    LAPIC.enable();

-static IDT: Lazy<InterruptDescriptorTable> = Lazy::new(|| {
-    let mut idt = InterruptDescriptorTable::new();
-    unsafe {
-        idt.double_fault
-            .set_handler_fn(double_fault)
-            .set_stack_index(super::gdt::DOUBLE_FAULT_IX);
-    }
-    idt.page_fault.set_handler_fn(page_fault);
-
-    idt[Interrupt::ApicErr as u8].set_handler_fn(apic_err);
-    idt[Interrupt::Spurious as u8].set_handler_fn(spurious);
-    idt[Interrupt::Timer as u8].set_handler_fn(timer);
-
-    idt
-});
+    x86_64::instructions::interrupts::enable();
+}

 extern "x86-interrupt" fn double_fault(stack_frame: InterruptStackFrame, error_code: u64) -> ! {
    panic!("Double fault: error code {error_code} \n{stack_frame:#?}")
@ -64,7 +60,9 @@ extern "x86-interrupt" fn page_fault(
 }

 extern "x86-interrupt" fn timer(_isf: InterruptStackFrame) {
-    unsafe { LAPIC.lock().end_of_interrupt() };
+    unsafe {
+        LAPIC.end_of_interrupt();
+    }
 }

 extern "x86-interrupt" fn apic_err(_: InterruptStackFrame) {
@ -72,5 +70,7 @@ extern "x86-interrupt" fn apic_err(_: InterruptStackFrame) {
 }

 extern "x86-interrupt" fn spurious(_: InterruptStackFrame) {
-    unsafe { LAPIC.lock().end_of_interrupt() };
+    unsafe {
+        LAPIC.end_of_interrupt();
+    }
 }
--- a/kernel/src/holeybytes/ecah.rs
+++ b/kernel/src/holeybytes/ecah.rs
@ -13,7 +13,7 @@ use {

 pub fn handler(vm: &mut Vm) {
    let ecall_number = vm.registers[2].cast::<u64>();
-
+    // log::info!("eca called :pensive:");
    // debug!("Ecall number {:?}", ecall_number);
    //info!("Register dump: {:?}", vm.registers);

@ -97,61 +97,35 @@ pub fn handler(vm: &mut Vm) {
                    let msg_vec = block_read(mem_addr, length);
                    let msg_type = msg_vec[0];
                    match msg_type {
-                        0 => 'wow: {
-                            let size = match msg_vec[0] {
-                                0 => 1,
-                                1 => 2,
-                                2 => 4,
-                                _ => {
-                                    error!("Tried to write more than 32 bits");
-                                    break 'wow;
-                                }
+                        0 => unsafe {
+                            let size = msg_vec[1];
+                            let addr = u16::from_le_bytes(msg_vec[2..4].try_into().unwrap());
+                            let value = match size {
+                                0 => x86_in::<u8>(addr) as u64,
+                                1 => x86_in::<u16>(addr) as u64,
+                                2 => x86_in::<u32>(addr) as u64,
+                                _ => panic!("Trying to read size other than: 8, 16, 32 from port."),
                            };
-                            let addr = u16::from_le_bytes(msg_vec[1..3].try_into().unwrap());
-                            let value = unsafe {
-                                match size {
-                                    1 => x86_in::<u8>(addr) as u64,
-                                    2 => x86_in::<u16>(addr) as u64,
-                                    4 => x86_in::<u32>(addr) as u64,
-                                    _ => panic!("how?"),
-                                }
-                            };
-                            trace!("Read the value {} from address {}", value, addr);
+                            // info!("Read the value {} from address {}", value, addr);
                            vm.registers[1] = hbvm::value::Value(value);
-                        }
-                        1 => 'wow: {
-                            let size = match msg_vec[1] {
-                                0 => 1,
-                                1 => 2,
-                                2 => 4,
-                                _ => {
-                                    error!("Tried to write more than 32 bits");
-                                    break 'wow;
-                                }
-                            };
-                            let addr = unsafe {
-                                u16::from_le_bytes(msg_vec[1..3].try_into().unwrap_unchecked())
-                            };
+                        },
+                        1 => unsafe {
+                            let size = msg_vec[1];
+                            let addr = u16::from_le_bytes(msg_vec[2..4].try_into().unwrap());
                            trace!("Setting address {}", addr);
-                            unsafe {
                            match size {
-                                    1 => x86_out(addr, msg_vec[3]),
+                                0 => x86_out(addr, msg_vec[4]),
+                                1 => x86_out(
+                                    addr,
+                                    u16::from_le_bytes(msg_vec[4..6].try_into().unwrap_unchecked()),
+                                ),
                                2 => x86_out(
                                    addr,
-                                        u16::from_le_bytes(
-                                            msg_vec[3..5].try_into().unwrap_unchecked(),
-                                        ),
-                                    ),
-                                    4 => x86_out(
-                                        addr,
-                                        u32::from_le_bytes(
-                                            msg_vec[3..7].try_into().unwrap_unchecked(),
-                                        ),
+                                    u32::from_le_bytes(msg_vec[4..8].try_into().unwrap_unchecked()),
                                ),
                                _ => panic!("How?"),
                            }
-                            }
-                        }
+                        },
                        _ => {}
                    }
                }
--- a/kernel/src/holeybytes/kernel_services/mem_serve.rs
+++ b/kernel/src/holeybytes/kernel_services/mem_serve.rs
@ -1,6 +1,6 @@
 use {
    crate::holeybytes::{kernel_services::block_read, Vm},
-    alloc::alloc::{alloc_zeroed, dealloc},
+    alloc::alloc::{alloc, dealloc},
    core::alloc::Layout,
    log::{debug, info},
 };
@ -17,7 +17,7 @@ pub enum MemoryQuotaType {
 }

 fn alloc_page(vm: &mut Vm, _mem_addr: u64, _length: usize) -> Result<(), MemoryServiceError> {
-    let ptr = unsafe { alloc_zeroed(Layout::new::<[u8; 4096]>()) };
+    let ptr = unsafe { alloc(Layout::from_size_align_unchecked(4096, 4096)) };
    info!("Block address: {:?}", ptr);
    vm.registers[1] = hbvm::value::Value(ptr as u64);
    vm.registers[2] = hbvm::value::Value(4096);
@ -40,9 +40,9 @@ pub fn memory_msg_handler(
            log::debug!("Allocating {} pages @ {:x}", page_count, mptr);

            let ptr = unsafe {
-                alloc_zeroed(Layout::from_size_align_unchecked(
+                alloc(Layout::from_size_align_unchecked(
                    page_count as usize * 4096,
-                    1,
+                    4096,
                ))
            };

@ -59,7 +59,7 @@ pub fn memory_msg_handler(
            unsafe {
                dealloc(
                    mptr as *mut u8,
-                    Layout::from_size_align_unchecked(page_count as usize * 4096, 1),
+                    Layout::from_size_align_unchecked(page_count as usize * 4096, 4096),
                )
            }
        }
--- a/kernel/src/holeybytes/kernel_services/mod.rs
+++ b/kernel/src/holeybytes/kernel_services/mod.rs
@ -6,6 +6,6 @@ pub mod mem_serve;
 pub mod service_definition_service;

 #[inline(always)]
-pub fn block_read<'a>(mem_addr: u64, length: usize) -> &'a [u8] {
-    unsafe { slice::from_raw_parts(mem_addr as *const u8, length) }
+pub fn block_read<'a>(mem_addr: u64, length: usize) -> &'a mut [u8] {
+    unsafe { slice::from_raw_parts_mut(mem_addr as *mut _, length) }
 }
--- a/kernel/src/holeybytes/mod.rs
+++ b/kernel/src/holeybytes/mod.rs
@ -3,7 +3,7 @@ mod kernel_services;
 mod mem;

 use {
-    alloc::alloc::{alloc_zeroed, dealloc},
+    alloc::alloc::{alloc, dealloc},
    core::{
        alloc::Layout,
        future::Future,
@ -61,29 +61,23 @@ impl<'p> Future for ExecThread {
    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        match self.vm.run() {
            Err(err) => {
-                error!("HBVM Error\r\nRegister dump: {:?}", self.vm.registers);
-                Poll::Ready(Err(err))
-            }
-            Ok(VmRunOk::End) => Poll::Ready(Ok(())),
-            Ok(VmRunOk::Ecall) => {
-                ecah::handler(&mut self.vm);
-                cx.waker().wake_by_ref();
-                Poll::Pending
-            }
-            Ok(VmRunOk::Timer) => {
-                cx.waker().wake_by_ref();
-                Poll::Pending
+                log::error!("HBVM Error\r\nRegister dump: {:?}", self.vm.registers,);
+                return Poll::Ready(Err(err));
            }
+            Ok(VmRunOk::End) => return Poll::Ready(Ok(())),
+            Ok(VmRunOk::Ecall) => ecah::handler(&mut self.vm),
+            Ok(VmRunOk::Timer) => (),
            Ok(VmRunOk::Breakpoint) => {
-                error!(
+                log::error!(
                    "HBVM Debug breakpoint\r\nRegister dump: {:?}",
-                    self.vm.registers
+                    self.vm.registers,
                );
+            }
+        }
+
        cx.waker().wake_by_ref();
        Poll::Pending
    }
-        }
-    }
 }

 struct PageFaultHandler;
@ -108,5 +102,5 @@ const fn stack_layout() -> Layout {

 #[inline(always)]
 fn allocate_stack() -> *mut u8 {
-    unsafe { alloc_zeroed(stack_layout()) }
+    unsafe { alloc(stack_layout()) }
 }
--- a/kernel/src/kmain.rs
+++ b/kernel/src/kmain.rs
@ -12,7 +12,7 @@ use {
    hashbrown::HashMap,
    hbvm::mem::Address,
    limine::{Framebuffer, FramebufferRequest, NonNullPtr},
-    log::{debug, info},
+    log::{debug, trace},
    spin::{Lazy, Mutex},
 };

@ -36,9 +36,9 @@ pub fn kmain(_cmdline: &str, boot_modules: BootModules) -> ! {
    let dt = DEVICE_TREE.lock();

    // TODO(Able): This line causes a deadlock
-    info!("Device Tree: {}", dt);
+    debug!("Device Tree: {}", dt);

-    info!("Boot complete. Moving to init_system");
+    trace!("Boot complete. Moving to init_system");

    // TODO: schedule the disk driver from the initramfs
    // TODO: schedule the filesystem driver from the initramfs
@ -60,39 +60,32 @@ pub fn kmain(_cmdline: &str, boot_modules: BootModules) -> ! {
        disp.set_attribute("pitch", fb1.pitch);
        dt.devices.insert("Displays".to_string(), alloc::vec![disp]);
    }
-    log::info!("Graphics initialised");
-    log::info!(
+    debug!("Graphics initialised");
+    debug!(
        "Graphics front ptr {:?}",
        fb1.address.as_ptr().unwrap() as *const u8
    );

    let mut executor = crate::task::Executor::new(256);
-    let bm_take = boot_modules.len();
    unsafe {
-        for module in boot_modules.into_iter().take(bm_take) {
-            let mut cmd = module.cmd;
-            if cmd.len() > 2 {
-                // // Remove the quotes
-                // cmd.remove(0);
-                // cmd.pop();
-                cmd = &cmd[1..cmd.len()]
-            }
+        for module in boot_modules.iter() {
+            let cmd = module.cmd.trim_matches('"');
            let cmd_len = cmd.len() as u64;

            log::info!("Spawning {} with arguments \"{}\"", module.path, cmd);

-            executor.spawn(async move {
            let mut thr = ExecThread::new(&module.bytes, Address::new(0));
            if cmd_len > 0 {
-                    thr.set_arguments(cmd.as_bytes().as_ptr() as u64, cmd_len);
+                thr.set_arguments(cmd.as_ptr() as u64, cmd_len);
            }
+            executor.spawn(async move {
                if let Err(e) = thr.await {
                    log::error!("{e:?}");
                }
            })
        }

-        info!("Random number: {}", hardware_random_u64());
+        debug!("Random number: {}", hardware_random_u64());

        executor.run();
    };
--- a/kernel/src/lib.rs
+++ b/kernel/src/lib.rs
@ -2,8 +2,9 @@
 //! Named akern.
 //! Akern is woefully undersupported at the moment but we are looking to add support improve hardware discovery and make our lives as kernel and operating system developers easier and better
 #![no_std]
-#![feature(new_uninit)]
 #![feature(
+    exclusive_wrapper,
+    new_uninit,
    abi_x86_interrupt,
    alloc_error_handler,
    ptr_sub_ptr,
--- a/sysdata/libraries/stn/src/buffer.hb
+++ b/sysdata/libraries/stn/src/buffer.hb
@ -4,10 +4,8 @@ receive_message := fn(buffer_id: int, memory_map_location: ^u8, length: int): ^u
 	return @eca(^u8, 4, buffer_id, memory_map_location, length)
 }

-send_message := fn(msg: ^u8, buffer_id: int): void {
-	msg_length := @inline(string.length, msg)
-	@eca(i32, 3, buffer_id, msg, msg_length)
-	return
+send_message := fn(msg: ^u8, buffer_id: int, length: int): void {
+	return @eca(void, 3, buffer_id, msg, length)
 }

 create := fn(msg: ^u8): int {
--- a/sysdata/libraries/stn/src/memory.hb
+++ b/sysdata/libraries/stn/src/memory.hb
@ -17,38 +17,23 @@ release_page := fn(ptr: ^u8, page_count: u8): void {
 	return @eca(void, 3, 2, msg, 12)
 }

+OutbMsg := struct {a: u8, b: u8, addr: u16, value: u8}
+InbMsg := struct {a: u8, b: u8, addr: u16}
+OutlMsg := struct {a: u8, b: u8, addr: u16, value: u32}
+InlMsg := struct {a: u8, b: u8, addr: u16}
+
 outb := fn(addr: u16, value: u8): void {
-	msg := "\0\0\0\0\0";
-	*@as(^u8, msg) = @as(u8, 1);
-	*@as(^u8, msg + 1) = @as(u8, 0);
-	*@as(^u16, @bitcast(msg + 2)) = addr;
-	*@as(^u8, msg + 4) = value
-	@eca(void, 3, 3, msg, 5)
-	return
+	return @eca(void, 3, 3, &OutbMsg.(1, 0, addr, value), @sizeof(OutbMsg))
 }

 inb := fn(addr: u16): u8 {
-	msg := "\0\0\0\0";
-	*@as(^u8, msg) = @as(u8, 0);
-	*@as(^u8, msg + 1) = @as(u8, 0);
-	*@as(^u16, @bitcast(msg + 2)) = addr
-	return @eca(u8, 3, 3, msg, 4)
+	return @eca(u8, 3, 3, &InbMsg.(0, 0, addr), @sizeof(InbMsg))
 }

 outl := fn(addr: u16, value: u32): void {
-	msg := "\0\0\0\0\0\0\0\0";
-	*@as(^u8, msg) = @as(u8, 1);
-	*@as(^u8, msg + 1) = @as(u8, 2);
-	*@as(^u16, @bitcast(msg + 2)) = addr;
-	*@as(^u32, @bitcast(msg + 4)) = value
-	@eca(void, 3, 3, msg, 8)
-	return
+	return @eca(void, 3, 3, &OutlMsg.(1, 2, addr, value), @sizeof(OutlMsg))
 }

 inl := fn(addr: u16): u32 {
-	msg := "\0\0\0\0";
-	*@as(^u8, msg) = @as(u8, 0);
-	*@as(^u8, msg + 1) = @as(u8, 2);
-	*@as(^u16, @bitcast(msg + 2)) = addr
-	return @eca(u32, 3, 3, msg, 4)
+	return @eca(u32, 3, 3, &InlMsg.(0, 2, addr), @sizeof(InlMsg))
 }
--- a/sysdata/libraries/stn/src/string.hb
+++ b/sysdata/libraries/stn/src/string.hb
@ -4,19 +4,29 @@ length := fn(ptr: ^u8): int {
 	return len
 }

+// WTFFF is wrong with display_int
 display_int := fn(num: int, p: ^u8): ^u8 {
-	i := 0
+	ptr := p
+	negative := num < 0
+	if negative {
+		num = -num
+	}
 	if num == 0 {
-		*p = 48
-		return p
-	}
+		*ptr = 48
+		ptr += 1
+	} else {
 		loop if num == 0 break else {
-		*(p + i) = num % 10 + 48
+			*ptr = num % 10 + 48
+			ptr += 1
 			num /= 10
-		i += 1
 		}
-	@inline(reverse, p);
-	*(p + i) = 0
+	}
+	if negative {
+		*ptr = 45
+		ptr += 1
+	};
+	*ptr = 0
+	@inline(reverse, p)
 	return p
 }

--- a/sysdata/programs/kvstore/README.md
+++ b/sysdata/programs/kvstore/README.md
@ -1,2 +0,0 @@
-# KVStore
-This is a small single process in memory key value store.
--- a/sysdata/programs/kvstore/src/main.hb
+++ b/sysdata/programs/kvstore/src/main.hb
@ -1,37 +0,0 @@
-Message := struct {
-    msg_type: u8,
-    key: String,
-    value: String,
-}
-
-/*
-# Message Type 
-0 => Set Key type
-1 => Get Key
-*/
-
-recv_msg:= fn(): Message {
-    return Message.{
-        msg_type: 0,
-        key: "",
-        value: "",
-    }
-}
-
-main := fn(): int {
-    loop {
-        msg := recv_msg();
-        if msg.msg_type == 0 {
-            continue;
-        }
-        if msg.msg_type == 1 {
-            continue;
-        }
-        if 2 <= msg.msg_type {
-            error("Unexpected message type in the bagging area");
-            continue;
-        }
-    }
-
-    return 0;
-}
--- a/sysdata/programs/ps2_driver/README.md
+++ b/sysdata/programs/ps2_driver/README.md
@ -0,0 +1,3 @@
+# PS/2 Driver
+
+This program is a simple driver to read keypresses from a PS/2 Keyboard Also will contain an abstraction for the PS/2 controller in general so the Mouse code will probably also live here...maybe
--- a/sysdata/programs/ps2_driver/meta.toml
+++ b/sysdata/programs/ps2_driver/meta.toml
@ -0,0 +1,11 @@
+[package]
+name = "ps2_driver"
+authors = ["Talha Qamar"]
+
+[dependants.libraries]
+
+[dependants.binaries]
+hblang.version = "1.0.0"
+
+[build]
+command = "hblang src/main.hb"
--- a/sysdata/programs/ps2_driver/src/main.hb
+++ b/sysdata/programs/ps2_driver/src/main.hb
@ -0,0 +1,33 @@
+.{memory, log, string, buffer} := @use("../../../libraries/stn/src/lib.hb")
+
+send_byte := fn(byte: u8): u8 {
+	memory.outb(96, byte)
+	return memory.inb(96)
+}
+
+main := fn(): int {
+	send_byte(238)
+	log.info("PS/2 Driver Loaded\0")
+	if send_byte(238) == 238 {
+		log.info("PS/2 Keyboard Echoed\0")
+	}
+	a := 0
+	// a += 1
+	if send_byte(244) == 250 {
+		log.info("Enabled scanning\0")
+	}
+	buf := buffer.create("XKeyboard\0")
+	ptr := memory.request_page(1)
+	prev_input := 250
+	loop {
+		input := memory.inb(96)
+		if input == prev_input {
+			continue
+		}
+		prev_input = input
+		keycode_str := string.display_int(input, ptr)
+		log.info(keycode_str)
+		buffer.send_message(&input, buf, 1)
+	}
+	return 0
+}
--- a/sysdata/programs/render_example/src/main.hb
+++ b/sysdata/programs/render_example/src/main.hb
@ -1,4 +1,4 @@
-.{example} := @use("./examples/colors.hb")
+.{example} := @use("./examples/amogus.hb")

 main := fn(): void {
 	@inline(example)
--- a/sysdata/system_config.toml
+++ b/sysdata/system_config.toml
@ -41,5 +41,8 @@ resolution = "1024x768x24"
 # [boot.limine.ableos.modules.dt_buffer_test]
 # path = "boot:///dt_buffer_test.hbf"

-[boot.limine.ableos.modules.svga_driver]
-path = "boot:///svga_driver.hbf"
+# [boot.limine.ableos.modules.svga_driver]
+# path = "boot:///svga_driver.hbf"
+
+[boot.limine.ableos.modules.ps2_driver]
+path = "boot:///ps2_driver.hbf"
Author	SHA1	Message	Date
koniifer	41b339dfd0	omfg it's fixed 🙏	2024-09-16 21:56:52 +01:00
koniifer	a8d38e04c4	let's just use strings for now	2024-09-16 20:45:19 +01:00
koniifer	1f4fce0f66	please bugs begone	2024-09-16 20:15:51 +01:00
koniifer	b021fc5b86	bug squashing & testing	2024-09-15 17:01:29 +01:00