bug squashing & testing

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",
 ]
@@ -395,7 +395,7 @@ source = "git+https://git.ablecorp.us/AbleOS/holey-bytes.git#4a9b9de87fd56a6bbd5
 [[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#6968e7d769d905c41fbe4c195d9d34d3339c32cf"
 
 [[package]]
 name = "hblang"
@@ -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#6968e7d769d905c41fbe4c195d9d34d3339c32cf"
 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]]
@@ -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",

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 }

kernel/src/holeybytes/ecah.rs

@@ -97,55 +97,37 @@ 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: {
+                        0 => {
-                            let size = match msg_vec[0] {
+                            let size = msg_vec[1];
-                                0 => 1,
+                            let addr = u16::from_le_bytes(msg_vec[2..4].try_into().unwrap());
-                                1 => 2,
-                                2 => 4,
-                                _ => {
-                                    error!("Tried to write more than 32 bits");
-                                    break 'wow;
-                                }
-                            };
-                            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,
+                                    0 => x86_in::<u8>(addr) as u64,
-                                    2 => x86_in::<u16>(addr) as u64,
+                                    1 => x86_in::<u16>(addr) as u64,
-                                    4 => x86_in::<u32>(addr) as u64,
+                                    2 => 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: {
+                        1 => {
-                            let size = match msg_vec[1] {
+                            let size = msg_vec[1];
-                                0 => 1,
+                            let addr = u16::from_le_bytes(msg_vec[2..4].try_into().unwrap());
-                                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())
-                            };
                             trace!("Setting address {}", addr);
                             unsafe {
                                 match size {
-                                    1 => x86_out(addr, msg_vec[3]),
+                                    0 => x86_out(addr, msg_vec[4]),
-                                    2 => x86_out(
+                                    1 => x86_out(
                                         addr,
                                         u16::from_le_bytes(
-                                            msg_vec[3..5].try_into().unwrap_unchecked(),
+                                            msg_vec[4..6].try_into().unwrap_unchecked(),
                                         ),
                                     ),
-                                    4 => x86_out(
+                                    2 => x86_out(
                                         addr,
                                         u32::from_le_bytes(
-                                            msg_vec[3..7].try_into().unwrap_unchecked(),
+                                            msg_vec[4..8].try_into().unwrap_unchecked(),
                                         ),
                                     ),
                                     _ => panic!("How?"),

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] {
+pub fn block_read<'a>(mem_addr: u64, length: usize) -> &'a mut [u8] {
-    unsafe { slice::from_raw_parts(mem_addr as *const u8, length) }
+    unsafe { slice::from_raw_parts_mut(mem_addr as *mut _, length) }
 }

kernel/src/holeybytes/mod.rs

@@ -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);
+                log::error!("HBVM Error\r\nRegister dump: {:?}", self.vm.registers,);
-                Poll::Ready(Err(err))
+                return 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
             }
+            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;

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");
+    debug!("Graphics initialised");
-    log::info!(
+    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) {
+        for module in boot_modules.iter() {
-            let mut cmd = module.cmd;
+            let cmd = module.cmd.trim_matches('"');
-            if cmd.len() > 2 {
-                // // Remove the quotes
-                // cmd.remove(0);
-                // cmd.pop();
-                cmd = &cmd[1..cmd.len()]
-            }
             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();
     };

kernel/src/lib.rs

@@ -2,8 +2,8 @@
 //! 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(
+    new_uninit,
     abi_x86_interrupt,
     alloc_error_handler,
     ptr_sub_ptr,

sysdata/libraries/stn/src/memory.hb

@@ -18,21 +18,13 @@ release_page := fn(ptr: ^u8, page_count: u8): void {
 }
 
 outb := fn(addr: u16, value: u8): void {
-	msg := "\0\0\0\0\0";
+	msg := [u8; 5].(1, 0, @as(u8, addr & 0xFF), @as(u8, addr >> 8 & 0xFF), value)
-	*@as(^u8, msg) = @as(u8, 1);
+	return @eca(void, 3, 3, &msg, 5)
-	*@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
 }
 
 inb := fn(addr: u16): u8 {
-	msg := "\0\0\0\0";
+	msg := [u8; 4].(0, 0, @as(u8, addr & 0xFF), @as(u8, addr >> 8 & 0xFF))
-	*@as(^u8, msg) = @as(u8, 0);
+	return @eca(u8, 3, 3, &msg, 4)
-	*@as(^u8, msg + 1) = @as(u8, 0);
-	*@as(^u16, @bitcast(msg + 2)) = addr
-	return @eca(u8, 3, 3, msg, 4)
 }
 
 outl := fn(addr: u16, value: u32): void {

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

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"

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(string.display_int(input, ptr))
+		buffer.send_message(keycode_str, buf)
+	}
+	return 0
+}