minor jank auto resolution detection

memory bug fixes
update hblang
update render examples
obliterate render_driver (not useful)

.cargo/config.toml

@@ -1,3 +1,3 @@
 [alias]
-repbuild = "run --manifest-path ./repbuild/Cargo.toml -- "
+repbuild = "run --manifest-path ./repbuild/Cargo.toml -r --"
 dev = "run --manifest-path ./dev/Cargo.toml -r --"

.vscode/settings.json

@@ -1,6 +1,4 @@
 {
-   "editor.insertSpaces": false,
-   "editor.detectIndentation": false,
    "rust-analyzer.checkOnSave.allTargets": false,
    "rust-analyzer.showUnlinkedFileNotification": false,
    "C_Cpp.errorSquiggles": "disabled"

HELP.md

@@ -1,69 +0,0 @@
-### What are the requirements?
-- A machine with [Rustc Tier 1 platform support](https://doc.rust-lang.org/nightly/rustc/platform-support.html#tier-1-with-host-tools)
-- Rustup
-- QEMU (for executing)
-- GIT CLI
-
-### How do I run ableos?
-- It is recommended to run ableos under QEMU. Here is how:
-    - Install QEMU
-    - Clone ableos
-    - Go to ableos directory
-    - Pull the limine submodule with `git submodule update --init`
-    - Run `cargo repbuild help`
-
-### How can I contribute?
-- [Contribute code](#how-do-i-contribute-code)
-- [Run ableos on your machine](#how-do-i-run-ableos)
-- Find bugs
-- Create media showing ableos
-
-### How do I contribute code?
-- Start by forking ableos
-- Write something that runs in the userspace, for example:
-    - System drivers
-    - Programs
-    - Libraries
-- Patch bugs and improve code in the kernel
-- Ensure that the code is OK to be maintained by asking in the [discord](https://discord.gg/t5Wt3K4YNA)
-- When you have finished your changes, you can submit a pull request for review [here](https://git.ablecorp.us/ableos/ableos)
-
-### repbuild and kernel compile, but QEMU isn't starting
-- Ensure you have the `qemu-desktop-{arch}` for your OS and target architecture installed
-- Try running again with `--noaccel` if you have QEMU already
-
-### I have run using repbuild but it's slow
-- Ensure release mode is enabled with the `-r` flag
-- Remove the `--noaccel` flag if you can
-- If both of these are already done, there may be a problem with thee VM, kernel, your program, or the hblang compiler
-
-### Compiler is complaining about "reg id leaked"
-- [Submit](#how-do-i-report-a-compiler-bug) an issue, reg id leaked is a bug
-
-### My program isn't running
-- Refer to [here](#i-have-run-using-repbuild-but-its-slow), it may be that your program is simply starting slowly
-- Ensure that your program has a properly written meta.toml file
-- Ensure that your program is enabled in [system_config.toml](sysdata/system_config.toml)
-- Try running again with `--noaccel`, there is a known bug with some systems that prevents programs from starting.
-
-### Kernel panic??? Huh???
-- Kernel panics can be caused by improperly using memory (e.g, writing out of bounds)
-- Kernel panics are most likely to be caused when accessing memory or using `@eca` for kernel ecalls
-- [Report](#how-do-i-report-an-ableos-bug) a kernel panic
-
-### I am running in release mode but I have no debug info
-- Add the `-d` flag for debug info
-
-### What is `@eca`? How do I use it?
-- Eca is an ecall. They are similar to syscalls
-- The `@eca` directive takes the following arguments:
-    - `@eca(ecall_number, reg_1, ..., reg_n)`
-- The various ecalls have different arguments that are given by register values
-- Most ecalls are wrapped by `stn`, for example, `random`, `buffer`, and `memory` all make use of ecalls
-- All ecalls can be found [ecah.rs](kernel/src/holeybytes/ecah.rs)
-
-### How do I report an ableos bug?
-- Submit an issue [here](https://git.ablecorp.us/ableos/ableos/issues) or report it in the [discord](https://discord.gg/t5Wt3K4YNA)
-
-### How do I report a compiler bug?
-- Submit an issue [here](https://git.ablecorp.us/ableos/holey-bytes/issues) or report it in the [discord](https://discord.gg/t5Wt3K4YNA)

README.md

@@ -10,7 +10,15 @@ Donations can be made [here on Liberapay](https://liberapay.com/AbleTheAbove) or
 <img src="https://img.shields.io/liberapay/patrons/AbleTheAbove.svg?logo=liberapay">
 
 # Compiling
-See [HELP.md](HELP.md)
+AbleOS should be able to be built on any platform which is supported by
+[Rustc Tier 1 platform support](https://doc.rust-lang.org/nightly/rustc/platform-support.html#tier-1-with-host-tools).
+
+For running AbleOS, `repbuild` uses QEMU.
+
+## Steps
+1. Ensure you have qemu installed
+2. `git submodule update --init`
+3. `cargo repbuild run`
 
 # Developing
-There is a new work in progress developer tool for hblang. (see: dev folder)
+There is a new work in progress developer tool for hblang. 

STYLE_GUIDE.md

@@ -1,77 +0,0 @@
-# Style Guide
-This style guide has two modes that a guideline may be.
-
-`strict` means that prs will be rejected if they do not follow the guideline.
-
-`loose` means that a pr would be accepted but should later be fixed.
-
-## Empty Functions | loose
-Empty functions are typically a sign of an unfinished program or driver.
-
-In cases where there is a clear reason to have an empty function it will be allowed.
-For example FakeAlloc is only empty functions because it is a example of an the allocator api.
-
-### Allowed
-```rust
-/// in example.hb
-a := fn(): void {}
-```
-### Not Allowed
-```rust
-/// in fat32.hb
-a := fn(): void {}
-```
-## Magic Functions | loose
-'Magic functions' are what I am calling small helper functions that do one or two things.
-### Example
-```rust
-a := null
-magic_a := fn(){
-	a = 10
-}
-```
-The exact policy I want to have here is a bit fuzzy. I think that functions like this are nice in certain situations and not in others.
-Regardless of if you use them or not, put a comment above the function explaining rational.
-
-
-## Magic Numbers | loose
-The policy on magic numbers is make them const and have a comment above them. Typically linking to a source of information about the magic number.
-
-This helps cut down on magic numbers while making acceptable names and atleast half assed documentation. 
-
-Constants are inlined anyways, so its the same thing in the binary.
-
-```rust
-// The standard vga port is mapped at 0xB8000
-$VGA_PTR := 0xB8000
-```
-
-## Tabs Vs Spaces | strict
-I prefer for hblang code to use hard tabs.
-
-The rational behind this is that a tab is `1 Indent` which some developers might want to be various different sizes when displayed
-
-Soft tabs do not allow this user/editor specific as soft tabs always become spaces.
-
-Bottom line is this is an accessibility feature.
-
-There are some samples below.
-```
-\t means hard tab
-\n means new line
-\0x20 means space
-```
-
-### Allowed
-```rust
-if x == y {\n
-\tlog(z)\n
-}\n
-```
-
-### Not Allowed
-```rust
-if x == y {\n
-\0x20\0x20\0x20\0x20log(z)\n
-}\n
-```

dev/src/idl/mod.rs

@@ -1,84 +1,20 @@
-pub mod protocol;
+use logos::Logos;
 
-use std::io::Read;
-
-use {
-    logos::{Lexer, Logos},
-    protocol::Protocol,
-};
-
-#[derive(Logos, Debug, PartialEq, Clone)]
+#[derive(Logos, Debug, PartialEq)]
 #[logos(skip r"[ \t\n\f]+")] // Ignore this regex pattern between tokens
 enum Token {
     // Tokens can be literal strings, of any length.
     #[token("protocol")]
     Protocol,
 
-    #[token("{")]
-    LBrace,
+    #[token(".")]
+    Period,
 
-    #[token("}")]
-    RBrace,
-
-    #[token("(")]
-    LParen,
-
-    #[token(")")]
-    RParen,
-
-    #[token(":")]
-    Colon,
-    #[token(";")]
-    SemiColon,
-
-    #[token(",")]
-    Comma,
-
-    #[token("=")]
-    Equal,
-
-    #[token("->")]
-    RArrow,
-
-    #[regex("[a-zA-Z_]+", |lex|{lex.slice().to_string()})]
-    Text(String),
-
-    #[regex("[1234567890]+", |lex|{lex.slice().parse::<u64>().unwrap()})]
-    Number(u64),
-
-    #[regex(r"@[a-zA-Z_]+", |lex|{lex.slice().to_string()})]
-    Decorator(String),
-
-    #[regex(r#"@[a-zA-Z_]+\([a-zA-Z,0-9=]+\)"#, |lex|{lex.slice().to_string()})]
-    DecoratorOption(String),
+    // Or regular expressions.
+    #[regex("[a-zA-Z]+")]
+    Text,
 }
 
-pub fn build_idl(name: String) {
-    let contents = open_protocol(name);
-    let lex = Token::lexer(&contents);
-    let mut tokens = vec![];
-    for x in lex {
-        match x {
-            Ok(token) => {
-                println!("{:?}", token);
-                tokens.push(token);
-            }
-            Err(err) => println!("{:?}", err),
-        }
-    }
-    build(tokens);
-}
-
-fn build(a: Vec<Token>) {
-    for toke in a {
-        println!("{:?}", toke);
-    }
-}
-
-fn open_protocol(name: String) -> String {
-    let path = format!("sysdata/idl/{}/src/protocol.aidl", name);
-    let mut file = std::fs::File::open(path).unwrap();
-    let mut contents = String::new();
-    file.read_to_string(&mut contents).unwrap();
-    contents
+pub fn main() {
+    let mut lex = Token::lexer("Create ridiculously fast Lexers.");
 }

dev/src/idl/protocol.rs

@@ -1,17 +0,0 @@
-pub enum ProtocolTypes {
-    Byte,
-}
-
-pub struct Protocol {}
-impl Protocol {
-    pub fn is_empty(&self) -> bool {
-        true
-    }
-
-    pub fn validate_data(&self, data: Vec<u8>) -> bool {
-        if !data.is_empty() && self.is_empty() {
-            return false;
-        }
-        true
-    }
-}

dev/src/main.rs

@@ -1,6 +1,4 @@
 use std::io::Write;
-
-use idl::build_idl;
 pub mod idl;
 
 pub enum Options {
@@ -9,7 +7,7 @@ pub enum Options {
     New,
     Run,
 }
-#[derive(PartialEq, Debug)]
+#[derive(PartialEq)]
 pub enum DevelopmentType {
     Program,
     Library,
@@ -26,7 +24,7 @@ fn main() {
 
     match subcommand {
         "build" => {
-            let name = &args.pop().unwrap();
+            let name = &args[1];
             build(name.to_string())
         }
         "new" => {
@@ -72,27 +70,6 @@ pub fn new(development_type: DevelopmentType, name: String) {
     let readme_contents = format!("# {}", name);
     readme_file.write_all(readme_contents.as_bytes()).unwrap();
 
-    let contents = format!(
-        "[package]
-name = \"{}\"
-authors = [\"\"]
-
-[dependants.libraries]
-
-[dependants.binaries]
-hblang.version = \"1.0.0\"
-
-[build]
-command = \"hblang src/main.hb\"
-",
-        name
-    );
-
-    let toml_path_string = format!("{}/meta.toml", project_folder_path_string);
-    let mut readme_file = std::fs::File::create(toml_path_string.clone()).unwrap();
-
-    readme_file.write_all(contents.as_bytes()).unwrap();
-
     let src_folder_path_string = format!("{}/src", project_folder_path_string);
     std::fs::create_dir(src_folder_path_string.clone()).unwrap();
 
@@ -126,21 +103,8 @@ fn run() {
 
 fn build(name: String) {
     println!("building {}", name);
-    let mut a = name.split("/");
-    let dev_type = a.next().unwrap();
-    let name = a.next().unwrap().to_string();
-    match dev_type {
-        "programs" => build_program(name),
-        "idl" => build_idl(name),
-        _ => {
-            panic!()
-        }
-    }
 }
 
-pub fn build_program(_name: String) {}
-pub fn build_library(_name: String) {}
-
 fn help() {
     println!(
         "==========

flake.lock

@@ -1,96 +0,0 @@
-{
-  "nodes": {
-    "flake-utils": {
-      "inputs": {
-        "systems": "systems"
-      },
-      "locked": {
-        "lastModified": 1731533236,
-        "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=",
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
-        "type": "github"
-      },
-      "original": {
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "type": "github"
-      }
-    },
-    "nixpkgs": {
-      "locked": {
-        "lastModified": 1732014248,
-        "narHash": "sha256-y/MEyuJ5oBWrWAic/14LaIr/u5E0wRVzyYsouYY3W6w=",
-        "owner": "NixOS",
-        "repo": "nixpkgs",
-        "rev": "23e89b7da85c3640bbc2173fe04f4bd114342367",
-        "type": "github"
-      },
-      "original": {
-        "owner": "NixOS",
-        "ref": "nixos-unstable",
-        "repo": "nixpkgs",
-        "type": "github"
-      }
-    },
-    "nixpkgs_2": {
-      "locked": {
-        "lastModified": 1728538411,
-        "narHash": "sha256-f0SBJz1eZ2yOuKUr5CA9BHULGXVSn6miBuUWdTyhUhU=",
-        "owner": "NixOS",
-        "repo": "nixpkgs",
-        "rev": "b69de56fac8c2b6f8fd27f2eca01dcda8e0a4221",
-        "type": "github"
-      },
-      "original": {
-        "owner": "NixOS",
-        "ref": "nixpkgs-unstable",
-        "repo": "nixpkgs",
-        "type": "github"
-      }
-    },
-    "root": {
-      "inputs": {
-        "flake-utils": "flake-utils",
-        "nixpkgs": "nixpkgs",
-        "rust-overlay": "rust-overlay"
-      }
-    },
-    "rust-overlay": {
-      "inputs": {
-        "nixpkgs": "nixpkgs_2"
-      },
-      "locked": {
-        "lastModified": 1732328983,
-        "narHash": "sha256-RHt12f/slrzDpSL7SSkydh8wUE4Nr4r23HlpWywed9E=",
-        "owner": "oxalica",
-        "repo": "rust-overlay",
-        "rev": "ed8aa5b64f7d36d9338eb1d0a3bb60cf52069a72",
-        "type": "github"
-      },
-      "original": {
-        "owner": "oxalica",
-        "repo": "rust-overlay",
-        "type": "github"
-      }
-    },
-    "systems": {
-      "locked": {
-        "lastModified": 1681028828,
-        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
-        "owner": "nix-systems",
-        "repo": "default",
-        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nix-systems",
-        "repo": "default",
-        "type": "github"
-      }
-    }
-  },
-  "root": "root",
-  "version": 7
-}

flake.nix

@@ -1,30 +0,0 @@
-{
-  description = "A devShell example";
-
-  inputs = {
-    nixpkgs.url      = "github:NixOS/nixpkgs/nixos-unstable";
-    rust-overlay.url = "github:oxalica/rust-overlay";
-    flake-utils.url  = "github:numtide/flake-utils";
-  };
-
-  outputs = { self, nixpkgs, rust-overlay, flake-utils }:
-    flake-utils.lib.eachDefaultSystem (system:
-      let
-        overlays = [ (import rust-overlay) ];
-        pkgs = import nixpkgs {
-          inherit system overlays;
-        };
-
-        rustToolchain = pkgs.pkgsBuildHost.rust-bin.fromRustupToolchainFile ./rust-toolchain.toml;
-      in
-      with pkgs;
-      {
-        devShells.default = mkShell {
-          buildInputs = [
-            rustToolchain
-            qemu_full
-          ];
-        };
-      }
-    );
-}

kernel/.cargo/config.toml

@@ -4,3 +4,6 @@ build-std-features = ["compiler-builtins-mem"]
 
 [build]
 target = "./targets/x86_64-ableos.json"
+
+[target.'cfg(target_arch = "x86_64")']
+rustflags = ["-C", "target-feature=+rdrand"]

kernel/Cargo.toml

@@ -3,15 +3,10 @@ edition = "2021"
 name = "kernel"
 version = "0.2.0"
 
-[features]
-ktest = []
 
 [dependencies]
-# embedded-graphics = "0.8"
-hbvm = { git = "https://git.ablecorp.us/AbleOS/holey-bytes.git", features = [
-	"nightly",
-] }
-ktest_macro = { path = "ktest_macro" }
+embedded-graphics = "0.8"
+hbvm.git = "https://git.ablecorp.us/ableos/holey-bytes"
 log = "0.4"
 spin = "0.9"
 slab = { version = "0.4", default-features = false }
@@ -19,35 +14,42 @@ uart_16550 = { version = "0.3", features = ["nightly"] }
 xml.git = "https://git.ablecorp.us/ableos/ableos_userland"
 versioning.git = "https://git.ablecorp.us/ableos/ableos_userland"
 # able_graphics_library.git = "https://git.ablecorp.us/ableos/ableos_userland"
-hashbrown = { version = "0.15", features = ["nightly"] }
-limine = "0.1"
+hashbrown = { version = "0.14", features = ["nightly"] }
+
+[dependencies.limine]
+version = "0.1"
+#git = "https://github.com/limine-bootloader/limine-rs"
 
 [dependencies.crossbeam-queue]
 version = "0.3"
 default-features = false
 features = ["alloc", "nightly"]
 
+# [dependencies.clparse]
+# git = "https://git.ablecorp.us/ableos/ableos_userland"
+# default-features = false
+
 [dependencies.derive_more]
 version = "1"
 default-features = false
 features = [
-	"add",
-	"add_assign",
-	"constructor",
-	"display",
-	"from",
-	"into",
-	"mul",
-	"mul_assign",
-	"not",
-	"sum",
+    "add",
+    "add_assign",
+    "constructor",
+    "display",
+    "from",
+    "into",
+    "mul",
+    "mul_assign",
+    "not",
+    "sum",
 ]
 
 
 [target.'cfg(target_arch = "x86_64")'.dependencies]
 x86_64 = "0.15"
 x2apic = "0.4"
-# virtio-drivers = "0.7"
+virtio-drivers = "0.7"
 
 [target.'cfg(target_arch = "riscv64")'.dependencies]
 sbi = "0.2.0"

kernel/ktest_macro/Cargo.toml

@@ -1,11 +0,0 @@
-[package]
-edition = "2021"
-name = "ktest_macro"
-version = "0.1.0"
-
-[lib]
-proc-macro = true
-
-[dependencies]
-quote = "1.0.37"
-syn = { version = "2.0.89", features = ["full"] }

kernel/ktest_macro/src/lib.rs

@@ -1,86 +0,0 @@
-extern crate proc_macro;
-extern crate quote;
-extern crate syn;
-
-use {
-    proc_macro::TokenStream,
-    quote::quote,
-    syn::{parse::Parse, parse_macro_input, Expr, ItemFn, Token}
-};
-
-struct KtestInput {
-    lhs: Expr,
-    _comma: Token![,],
-    rhs: Expr,
-}
-
-impl Parse for KtestInput {
-    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
-        Ok(Self {
-            lhs: input.parse()?,
-            _comma: input.parse()?,
-            rhs: input.parse()?,
-        })
-    }
-}
-
-#[proc_macro]
-pub fn ktest_eq(item: TokenStream) -> TokenStream {
-    let input = parse_macro_input!(item as KtestInput);
-
-    let lhs = input.lhs;
-    let rhs = input.rhs;
-
-    let out = quote! {
-        if #lhs != #rhs {
-            return Err(name);
-        }
-    };
-    TokenStream::from(out)
-}
-
-#[proc_macro]
-pub fn ktest_neq(item: TokenStream) -> TokenStream {
-    let input = parse_macro_input!(item as KtestInput);
-
-    let lhs = input.lhs;
-    let rhs = input.rhs;
-
-    let out = quote! {
-        if #lhs == #rhs {
-            return Err(name);
-        }
-    };
-    TokenStream::from(out)
-}
-
-#[proc_macro_attribute]
-pub fn ktest(_attr: TokenStream, item: TokenStream) -> TokenStream {
-    let input = parse_macro_input!(item as ItemFn);
-    let test_name = &input.sig.ident;
-    let test_string = test_name.to_string();
-    let static_var_name = syn::Ident::new(
-        &format!("__ktest_{}", test_name).to_uppercase(),
-        test_name.span(),
-    );
-
-    let block = &input.block;
-    let out = quote! {
-        #[cfg(feature = "ktest")]
-        fn #test_name() -> Result<String, String> {
-            use crate::alloc::string::ToString;
-            let name = #test_string.to_string();
-
-            #block
-
-            return Ok(name);
-        }
-
-        #[cfg(feature = "ktest")]
-        #[unsafe(link_section = ".note.ktest")]
-        #[used]
-        pub static #static_var_name: fn() -> Result<String, String> = #test_name;
-    };
-
-    TokenStream::from(out)
-}

kernel/lds/aarch64-qemu.ld

@@ -6,11 +6,6 @@ SECTIONS
     .text.boot : { *(.text.boot) }
     .text : { *(.text) }
     .data : { *(.data) }
-    .note.ktest : {
-		__ktest_start = .;
-    	*(.note.ktest)
-    	__ktest_end = .;
-	}
     .rodata : { *(.rodata) }
     .bss : {
         *(COMMON)

kernel/lds/x86_64.ld

@@ -38,15 +38,7 @@ SECTIONS
 
     .data : {
         *(.data .data.*)
-        *(.got .got.*)
     } :data
-    
-    /* Add the .ktest section for test functions */
-    .note.ktest : {
-        __ktest_start = .;   /* Mark the beginning of the section */
-        *(.note.ktest)            /* Include all items in the .ktest section */
-        __ktest_end = .;     /* Mark the end of the section */
-    }
 
     .bss : {
         *(COMMON)

kernel/src/arch/aarch64/device_info_collector.rs

@@ -1,5 +1,6 @@
 use {
-    crate::{device_tree::DeviceTree, kmain::DEVICE_TREE},
+    crate::{alloc::string::ToString, device_tree::DeviceTree, kmain::DEVICE_TREE},
+    alloc::string::String,
     core::arch::asm,
     xml::XMLElement,
 };
@@ -27,7 +28,7 @@ fn collect_cpu_info(device_tree: &mut DeviceTree) {
     cpus.push(cpu);
 }
 
-fn cpu_id<'a>() -> (&'a str, u64) {
+fn cpu_id() -> (String, u64) {
     let mut cpu_id: u64;
     unsafe {
         asm!("mrs {cpu_id}, MIDR_EL1",
@@ -38,11 +39,11 @@ fn cpu_id<'a>() -> (&'a str, u64) {
     let cpu_name = match cpu_id {
         // the source of these two was a stackoverflow question
         // https://raspberrypi.stackexchange.com/questions/117175/how-do-i-read-the-cpuid-in-aarch64-asm
-        0x410FD034 => "Cortex-A53",
-        0x410FD083 => "Cortex-A72",
+        0x410FD034 => "Cortex-A53".to_string(),
+        0x410FD083 => "Cortex-A72".to_string(),
         // the source of this one was checking the cpu id :thinking:
-        0x410FD493 => "Neoverse N2",
-        _ => "Unknown",
+        0x410FD493 => "Neoverse N2".to_string(),
+        _ => "Unknown".to_string(),
     };
     log::trace!("CPU Name: {cpu_name} - CPU ID: 0x{:X}", cpu_id);
 

kernel/src/arch/aarch64/logging.rs

@@ -1,9 +1,9 @@
 use {crate::logger::TERMINAL_LOGGER, core::fmt::Write, spin::Mutex};
-pub static SERIAL_CONSOLE: Mutex<SerialConsole> = Mutex::new(SerialConsole {
+static SERIAL_CONSOLE: Mutex<SerialConsole> = Mutex::new(SerialConsole {
     uart: 0x09000000 as *mut u8,
 });
 
-pub struct SerialConsole {
+struct SerialConsole {
     uart: *mut u8,
 }
 
@@ -22,7 +22,7 @@ unsafe impl Send for SerialConsole {}
 
 pub fn log(args: core::fmt::Arguments<'_>) -> core::fmt::Result {
     SERIAL_CONSOLE.lock().write_fmt(args)?;
-    // TERMINAL_LOGGER.lock().write_fmt(args)?;
+    TERMINAL_LOGGER.lock().write_fmt(args)?;
 
     Ok(())
 }

kernel/src/arch/mod.rs

@@ -14,29 +14,3 @@ arch_cond!(
     riscv64: "riscv64",
     x86_64: "x86_64",
 );
-
-#[cfg(target_arch = "x86_64")]
-use {crate::arch::interrupts::Interrupt, alloc::string::String};
-#[cfg(target_arch = "x86_64")]
-pub struct InterruptList {
-    list: HashMap<Interrupt, String>,
-}
-#[cfg(target_arch = "x86_64")]
-use hashbrown::HashMap;
-#[cfg(target_arch = "x86_64")]
-impl InterruptList {
-    pub fn new() -> Self {
-        Self {
-            list: HashMap::new(),
-        }
-    }
-}
-#[cfg(target_arch = "x86_64")]
-use spin::{Lazy, Mutex};
-#[cfg(target_arch = "x86_64")]
-pub static INTERRUPT_LIST: Lazy<Mutex<InterruptList>> = Lazy::new(|| {
-    let mut il = InterruptList::new();
-    use crate::alloc::string::ToString;
-    il.list.insert(Interrupt::Timer, "PS/2 Mouse".to_string());
-    Mutex::new(il)
-});

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 = 1;
+const STACK_ALIGNMENT: usize = 4096;
 
 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(layout);
+        let stack = alloc::alloc::alloc_zeroed(layout);
         VirtAddr::from_ptr(stack) + STACK_SIZE as u64
     };
 

kernel/src/arch/x86_64/interrupts.rs

@@ -1,54 +1,56 @@
+// 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},
 };
 
-/// 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() };
+pub unsafe fn init() {
+    trace!("Initialising IDT");
+    IDT.load();
+    Lazy::force(&LAPIC);
+    x86_64::instructions::interrupts::enable();
+}
 
 #[repr(u8)]
-#[derive(Debug, Eq, Hash, PartialEq)]
-
-pub enum Interrupt {
+enum Interrupt {
     Timer = 32,
+
     ApicErr = u8::MAX - 1,
     Spurious = u8::MAX,
 }
 
-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()
+pub(crate) static LAPIC: Lazy<Mutex<LocalApic>> = Lazy::new(|| {
+    let mut lapic = LocalApicBuilder::new()
         .timer_vector(Interrupt::Timer as usize)
         .error_vector(Interrupt::ApicErr as usize)
         .spurious_vector(Interrupt::Spurious as usize)
         .set_xapic_base(
-            x2apic::lapic::xapic_base()
+            unsafe { x2apic::lapic::xapic_base() }
                 + super::memory::HHDM_OFFSET.load(core::sync::atomic::Ordering::Relaxed),
         )
         .build()
-        .expect("Failed to setup Local APIC");
-    LAPIC.enable();
+        .expect("failed to setup Local APIC");
+    unsafe { lapic.enable() };
+    Mutex::new(lapic)
+});
 
-    x86_64::instructions::interrupts::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
+});
 
 extern "x86-interrupt" fn double_fault(stack_frame: InterruptStackFrame, error_code: u64) -> ! {
     panic!("Double fault: error code {error_code} \n{stack_frame:#?}")
@@ -62,52 +64,13 @@ extern "x86-interrupt" fn page_fault(
 }
 
 extern "x86-interrupt" fn timer(_isf: InterruptStackFrame) {
-    interrupt(Interrupt::Timer);
-
-    unsafe {
-        LAPIC.end_of_interrupt();
-    }
+    unsafe { LAPIC.lock().end_of_interrupt() };
 }
 
 extern "x86-interrupt" fn apic_err(_: InterruptStackFrame) {
-    interrupt(Interrupt::ApicErr);
-
     panic!("Internal APIC error");
 }
 
 extern "x86-interrupt" fn spurious(_: InterruptStackFrame) {
-    interrupt(Interrupt::Spurious);
-
-    unsafe {
-        LAPIC.end_of_interrupt();
-    }
-}
-
-#[allow(unused_imports)]
-fn interrupt(interrupt_type: Interrupt) {
-    use crate::{arch::INTERRUPT_LIST, kmain::EXECUTOR};
-    // let il = INTERRUPT_LIST.lock();
-    // let val = il.list.get(&interrupt_type).unwrap();
-
-    // use crate::holeybytes::kernel_services::service_definition_service::sds_search_service;
-    // let buffer = sds_search_service(val);
-    // if buffer != 0 {
-    //     use {crate::kmain::IPC_BUFFERS, alloc::vec::Vec};
-    //     let mut buffs = IPC_BUFFERS.lock();
-    //     match buffs.get_mut(&buffer) {
-    //         Some(buff) => {
-    //             let mut msg_vec = Vec::new();
-    //             msg_vec.push(0xFF);
-    //             buff.push(msg_vec.to_vec());
-    //             log::debug!("Sent Message {:?} to Buffer({})", msg_vec, buffer);
-    //         }
-    //         None => {
-    //             log::error!("Access of non-existent buffer {}", buffer)
-    //         }
-    //     }
-    // }
-
-    unsafe {
-        EXECUTOR.send_interrupt(interrupt_type as u8);
-    }
+    unsafe { LAPIC.lock().end_of_interrupt() };
 }

kernel/src/arch/x86_64/mod.rs

@@ -10,7 +10,7 @@ pub mod graphics;
 pub(crate) mod interrupts;
 pub mod logging;
 pub mod pci;
-// pub mod virtio;
+pub mod virtio;
 
 pub use {logging::log, memory::PAGE_SIZE};
 
@@ -30,11 +30,9 @@ const INITIAL_KERNEL_HEAP_SIZE: *const () = _initial_kernel_heap_size as _;
 
 #[no_mangle]
 #[naked]
-#[cfg(not(target_feature = "avx2"))]
 unsafe extern "C" fn _kernel_start() -> ! {
-    // Initialise SSE, then jump to kernel entrypoint
-    core::arch::naked_asm!(
-        // Initialise SSE
+    // Initialise SSE and jump to kernel entrypoint
+    core::arch::asm!(
         "mov rax, cr0",
         "and ax, 0xfffb",
         "or ax, 0x2",
@@ -42,74 +40,16 @@ unsafe extern "C" fn _kernel_start() -> ! {
         "mov rax, cr4",
         "or ax, 3 << 9",
         "mov cr4, rax",
-
-        // Jump to the kernel entry point
         "jmp {}",
         sym start,
+        options(noreturn),
     )
 }
 
-#[no_mangle]
-#[naked]
-#[cfg(target_feature = "avx2")]
-unsafe extern "C" fn _kernel_start() -> ! {
-    core::arch::naked_asm!(
-        // Enable protected mode and configure control registers
-        "mov rax, cr0",
-        "and ax, 0xFFFB",  // Clear CR0.EM (bit 2) for coprocessor emulation
-        "or ax, 0x2",      // Set CR0.MP (bit 1) for coprocessor monitoring
-        "mov cr0, rax",
-
-        "mov rax, cr4",
-        "or ax, (1 << 9) | (1 << 10)", // Set CR4.OSFXSR (bit 9) and CR4.OSXMMEXCPT (bit 10)
-        "mov cr4, rax",
-
-        // Enable OSXSAVE (required for AVX, AVX2, and XSAVE)
-        "mov rax, cr4",
-        "or eax, 1 << 18", // Set CR4.OSXSAVE (bit 18)
-        "mov cr4, rax",
-
-        // Enable AVX and AVX2 state saving
-        "xor rcx, rcx",
-        "xgetbv",
-        "or eax, 7",       // Enable SSE, AVX, and AVX2 state saving
-        "xsetbv",
-
-        // Check for AVX and XSAVE support
-        "mov eax, 1",
-        "cpuid",
-        "and ecx, 0x18000000",
-        "cmp ecx, 0x18000000",
-        "jne {1}",          // Jump if AVX/OSXSAVE is not supported
-
-        // Check for BMI2 and AVX2 support
-        "mov eax, 7",
-        "xor ecx, ecx",
-        "cpuid",
-        "and ebx, (1 << 8) | (1 << 5)", // Check BMI2 (bit 8) and AVX2 (bit 5)
-        "cmp ebx, (1 << 8) | (1 << 5)", // Compare to ensure both are supported
-
-        // Check for LZCNT and POPCNT support
-        "mov eax, 1",
-        "cpuid",
-        "and ecx, (1 << 5) | (1 << 23)", // Check LZCNT (bit 5) and POPCNT (bit 23)
-        "cmp ecx, (1 << 5) | (1 << 23)", // Compare to ensure both are supported
-
-        // Jump to the kernel entry point
-        "jmp {0}",
-        sym start,
-        sym oops,
-    )
-}
-
-unsafe extern "C" fn oops() -> ! {
-    panic!("your cpu is ancient >:(")
-}
-
 unsafe extern "C" fn start() -> ! {
     logging::init();
     crate::logger::init().expect("failed to set logger");
-    log::debug!("Initialising AKern {}", crate::VERSION);
+    log::info!("Initialising AKern {}", crate::VERSION);
 
     static HDHM_REQ: HhdmRequest = HhdmRequest::new(0);
     memory::init_pt(VirtAddr::new(
@@ -188,7 +128,7 @@ unsafe extern "C" fn start() -> ! {
     // TODO: Add in rdseed and rdrand as sources for randomness
     let _rand = xml::XMLElement::new("Random");
 
-    log::debug!("Getting boot modules");
+    log::trace!("Getting boot modules");
     let bm = MOD_REQ.get_response().get();
 
     let mut bootmodules = alloc::vec::Vec::new();
@@ -226,7 +166,7 @@ unsafe extern "C" fn start() -> ! {
                 break;
             }
         }
-        log::debug!("Boot module count: {:?}", bootmodules.len());
+        log::info!("Boot module count: {:?}", bootmodules.len());
         assert_eq!(bm.module_count, bootmodules.len() as u64);
     }
 
@@ -249,7 +189,6 @@ unsafe extern "C" fn start() -> ! {
 /// Spin loop
 pub fn spin_loop() -> ! {
     loop {
-        core::hint::spin_loop();
         x86_64::instructions::hlt()
     }
 }

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

@@ -8,12 +8,13 @@ pub struct PciDeviceInfo {
     pub full_class: PciFullClass,
     pub rev_id: u8,
 }
+use crate::alloc::string::ToString;
 
 /// Enumerate PCI devices and run initialisation routines on ones we support
 pub fn init(device_tree: &mut DeviceTree) {
     device_tree
         .devices
-        .insert("Unidentified PCI", alloc::vec![]);
+        .insert("Unidentified PCI".to_string(), alloc::vec![]);
     let mut devices = alloc::vec![];
 
     for bus in 0..=255 {
@@ -46,8 +47,7 @@ pub fn init(device_tree: &mut DeviceTree) {
                 pci_info.set_attribute("id", id);
                 pci_info.set_attribute("device", device_info.device);
                 pci_info.set_attribute("vendor", vendor);
-                pci_info.set_attribute("bus", bus);
-                pci_info.set_attribute("class", device_info.full_class);
+                pci_info.set_attribute("class", device_info.full_class.to_string());
                 dev.set_child(pci_info);
                 devices.push((dev_type, dev));
             }
@@ -68,8 +68,7 @@ pub fn check_device(bus: u8, device: u8) -> Option<PciDeviceInfo> {
         return None;
     }
 
-    let (reg2, addr) = unsafe { pci_config_read_2(bus, device, 0, 0x8) };
-    log::debug!("pci device-({}) addr {} is {}", device, addr, reg2);
+    let reg2 = unsafe { pci_config_read(bus, device, 0, 0x8) };
     let class = ((reg2 >> 16) & 0x0000_FFFF) as u16;
     let pci_class = PciFullClass::from_u16(class);
     let header_type = get_header_type(bus, device, 0);
@@ -460,7 +459,9 @@ unsafe fn pci_config_read(bus: u8, device: u8, func: u8, offset: u8) -> u32 {
     let func = func as u32;
     let offset = offset as u32;
     // construct address param
-    let address = (bus << 16) | (device << 11) | (func << 8) | (offset & 0xFC) | 0x8000_0000;
+    let address =
+        ((bus << 16) | (device << 11) | (func << 8) | (offset & 0xFC) | 0x8000_0000) as u32;
+
     // write address
     Port::new(0xCF8).write(address);
 
@@ -468,20 +469,6 @@ unsafe fn pci_config_read(bus: u8, device: u8, func: u8, offset: u8) -> u32 {
     Port::new(0xCFC).read()
 }
 
-unsafe fn pci_config_read_2(bus: u8, device: u8, func: u8, offset: u8) -> (u32, u32) {
-    let bus = bus as u32;
-    let device = device as u32;
-    let func = func as u32;
-    let offset = offset as u32;
-    // construct address param
-    let address = (bus << 16) | (device << 11) | (func << 8) | (offset & 0xFC) | 0x8000_0000;
-    // write address
-    Port::new(0xCF8).write(address);
-
-    // read data
-    (Port::new(0xCFC).read(), address)
-}
-
 unsafe fn pci_config_write(bus: u8, device: u8, func: u8, offset: u8, value: u32) {
     let bus = bus as u32;
     let device = device as u32;

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

@@ -1,5 +1,5 @@
 use {
-    core::ptr::NonNull,
+    core::{ptr::NonNull},
     virtio_drivers::{BufferDirection, Hal, PhysAddr},
 };
 

kernel/src/device_tree.rs

@@ -1,7 +1,11 @@
 //! A tree of hardware devices
 
-use {alloc::vec::Vec, core::fmt, hashbrown::HashMap};
-
+use {
+    crate::alloc::string::ToString,
+    alloc::{string::String, vec::Vec},
+    core::fmt,
+    hashbrown::HashMap,
+};
 /// A device object.
 /// TODO define device
 pub type Device = xml::XMLElement;
@@ -9,40 +13,38 @@ pub type Device = xml::XMLElement;
 /// A tree of devices
 // TODO: alphabetize this list
 #[derive(Debug)]
-pub struct DeviceTree<'a> {
+pub struct DeviceTree {
     /// The device tree
-    pub devices: HashMap<&'a str, Vec<Device>>,
+    pub devices: HashMap<String, Vec<Device>>,
 }
-impl<'a> DeviceTree<'a> {
+impl DeviceTree {
     /// Build the device tree. Does not populate the device tree
     pub fn new() -> Self {
         let mut dt = Self {
             devices: HashMap::new(),
         };
-        device_tree!(
-            dt,
-            [
-                "Mice",
-                "Keyboards",
-                "Controllers",
-                "Generic HIDs",
-                "Disk Drives",
-                "CD Drives",
-                "Batteries",
-                "Monitors",
-                "GPUs",
-                "CPUs",
-                "USB",
-                "Serial Ports",
-                "Cameras",
-                "Biometric Devices",
-            ]
-        );
+        device_tree!(dt, [
+            "Mice",
+            "Keyboards",
+            "Controllers",
+            "Generic HIDs",
+            "Disk Drives",
+            "CD Drives",
+            "Batteries",
+            "Monitors",
+            "GPUs",
+            "CPUs",
+            "USB",
+            "Serial Ports",
+            "Cameras",
+            "Biometric Devices",
+        ]);
         dt
     }
 }
-use crate::{device_tree, tab, utils::TAB};
-impl<'a> fmt::Display for DeviceTree<'a> {
+use crate::{utils::TAB, device_tree};
+use crate::tab;
+impl fmt::Display for DeviceTree {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         writeln!(f)?;
         for (device_type, devices) in &self.devices {

kernel/src/exe_format.rs

@@ -1,35 +0,0 @@
-enum Sections {
-    Header,
-    Code,
-    Data,
-    Debug,
-    Config,
-    Metadata,
-}
-
-// 64 byte header
-#[repr(packed)]
-struct AbleOsExecutableHeader {
-    magic_number: [u8; 3],
-    executable_version: u32,
-
-    code_length:     u64,
-    data_length:     u64,
-    debug_length:    u64,
-    config_length:   u64,
-    metadata_length: u64,
-}
-
-impl AbleOsExecutableHeader {
-    fn new() -> Self {
-        Self {
-            magic_number: [0x15, 0x91, 0xD2],
-            executable_version: 0,
-            code_length: 0,
-            config_length: 0,
-            data_length: 0,
-            debug_length: 0,
-            metadata_length: 0,
-        }
-    }
-}

kernel/src/holeybytes/ecah.rs

@@ -1,41 +1,19 @@
 //! Environment call handling routines
 
-use {alloc::boxed::Box, core::cell::LazyCell, hbvm::mem::Address};
-
-use crate::{
-    holeybytes::{
-        kernel_services::{
-            block_read, dt_msg_handler::dt_msg_handler, logging_service::log_msg_handler,
-            service_definition_service::sds_msg_handler,
-        },
-        ExecThread,
-    },
-    kmain::EXECUTOR,
-    task::Executor,
-};
+use crate::holeybytes::kernel_services::{block_read, service_definition_service::sds_msg_handler};
 
 use {
     super::Vm,
     crate::{arch, ipc::buffer::IpcBuffer, kmain::IPC_BUFFERS},
-    hbvm::value::Value,
-    log::{debug, error, info, trace},
+    log::{debug, error, info, trace, warn},
 };
 
-#[cfg(target_arch = "x86_64")]
-#[inline(always)]
-unsafe fn x86_out<T: x86_64::instructions::port::PortWrite>(address: u16, value: T) {
-    x86_64::instructions::port::Port::new(address).write(value);
-}
-#[cfg(target_arch = "x86_64")]
-#[inline(always)]
-unsafe fn x86_in<T: x86_64::instructions::port::PortRead>(address: u16) -> T {
-    x86_64::instructions::port::Port::new(address).read()
-}
-
-#[inline(always)]
-pub fn handler(vm: &mut Vm, pid: &usize) {
+pub fn handler(vm: &mut Vm) {
     let ecall_number = vm.registers[2].cast::<u64>();
 
+    // debug!("Ecall number {:?}", ecall_number);
+    //info!("Register dump: {:?}", vm.registers);
+
     match ecall_number {
         0 => {
             // TODO: explode computer
@@ -47,9 +25,9 @@ pub fn handler(vm: &mut Vm, pid: &usize) {
         1 => {
             // Make buffer
 
-            let bounded = match vm.registers[3] {
-                Value(0) => false,
-                Value(1) => true,
+            let bounded = match vm.registers[3].cast::<u64>() {
+                0 => false,
+                1 => true,
                 _ => {
                     panic!("Bad");
                 }
@@ -58,19 +36,22 @@ pub fn handler(vm: &mut Vm, pid: &usize) {
             let length = vm.registers[4].cast::<u64>();
 
             let mut buffs = IPC_BUFFERS.lock();
+            let abc;
 
+            match bounded {
+                false => {
+                    abc = IpcBuffer::new(false, 0);
+                }
+                true => {
+                    abc = IpcBuffer::new(true, length);
+                }
+            };
             let buff_id = arch::hardware_random_u64();
-            buffs.insert(
-                buff_id,
-                match bounded {
-                    false => IpcBuffer::new(false, 0),
-                    true => IpcBuffer::new(true, length),
-                },
-            );
+            buffs.insert(buff_id, abc);
+            info!("Buffer ID: {}", buff_id);
             vm.registers[1] = hbvm::value::Value(buff_id);
         }
         2 => {
-            log::error!("Oops, deleting buffers is not implemented.")
             // Delete buffer
         }
         3 => {
@@ -79,10 +60,7 @@ pub fn handler(vm: &mut Vm, pid: &usize) {
             let mem_addr = vm.registers[4].cast::<u64>();
             let length = vm.registers[5].cast::<u64>() as usize;
             trace!("IPC address: {:?}", mem_addr);
-
-            unsafe { LazyCell::<Executor>::get_mut(&mut EXECUTOR) }
-                .unwrap()
-                .send_buffer(buffer_id as usize);
+            use alloc::vec::Vec;
 
             match buffer_id {
                 0 => match sds_msg_handler(vm, mem_addr, length) {
@@ -100,138 +78,174 @@ pub fn handler(vm: &mut Vm, pid: &usize) {
                         Err(_) => {}
                     }
                 }
+                #[cfg(not(target_arch = "x86_64"))]
+                3 => info!("TODO: implement whatever buffer 3 does for no x86_64"),
                 #[cfg(target_arch = "x86_64")]
                 3 => {
+                    unsafe fn x86_out<T: x86_64::instructions::port::PortWrite>(
+                        address: u16,
+                        value: T,
+                    ) {
+                        x86_64::instructions::port::Port::new(address).write(value);
+                    }
+                    unsafe fn x86_in<T: x86_64::instructions::port::PortRead>(address: u16) -> T {
+                        x86_64::instructions::port::Port::new(address).read()
+                    }
                     let msg_vec = block_read(mem_addr, length);
                     let msg_type = msg_vec[0];
                     match msg_type {
-                        0 => unsafe {
-                            let size = msg_vec[1];
-                            let addr =
-                                u16::from_le_bytes(msg_vec[2..4].try_into().unwrap_unchecked());
-                            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."),
+                        0 => 'wow: {
+                            let size = match msg_vec[0] {
+                                0 => 1,
+                                1 => 2,
+                                2 => 4,
+                                _ => {
+                                    error!("Tried to write more than 32 bits");
+                                    break 'wow;
+                                }
                             };
-                            // info!("Read the value {} from address {}", value, addr);
+                            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);
                             vm.registers[1] = hbvm::value::Value(value);
-                        },
-                        1 => unsafe {
-                            let size = msg_vec[1];
-                            let addr =
-                                u16::from_le_bytes(msg_vec[2..4].try_into().unwrap_unchecked());
-                            // info!("Setting address {}", addr);
-
-                            match size {
-                                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,
-                                    u32::from_le_bytes(msg_vec[4..8].try_into().unwrap_unchecked()),
-                                ),
-                                _ => panic!("How?"),
+                        }
+                        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())
+                            };
+                            trace!("Setting address {}", addr);
+                            unsafe {
+                                match size {
+                                    1 => x86_out(addr, msg_vec[3]),
+                                    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(),
+                                        ),
+                                    ),
+                                    _ => panic!("How?"),
+                                }
                             }
-                        },
+                        }
                         _ => {}
                     }
                 }
-                #[cfg(not(target_arch = "x86_64"))]
-                3 => unimplemented!("TODO: implement whatever buffer 3 does for no x86_64"),
                 // source of rng
                 4 => {
-                    let block = block_read(mem_addr, length);
-                    block.chunks_mut(8.min(length)).for_each(|chunk| {
-                        chunk.clone_from_slice(
-                            &crate::arch::hardware_random_u64().to_le_bytes()[..chunk.len()],
-                        );
-                    });
-                    vm.registers[1] = hbvm::value::Value(mem_addr);
+                    // limit to last 32 bits
+                    vm.registers[1] =
+                        hbvm::value::Value(crate::arch::hardware_random_u64() & 0xFFFFFFFF);
                 }
-                5 => match dt_msg_handler(vm, mem_addr, length) {
-                    Ok(()) => {}
-                    Err(_) => log::error!("Improper dt query"),
-                },
-                6 => unsafe {
-                    let program = block_read(mem_addr, length);
-
-                    // decode AbleOS Executable format
-                    let header = &program[0..46];
-                    let magic_slice = &header[0..3];
-                    if magic_slice != [0x15, 0x91, 0xD2] {
-                        log::error!("Invalid magic number at the start of executable.");
-                        return;
-                    }
-
-                    let executable_format_version =
-                        u32::from_le_bytes(header[3..7].try_into().unwrap());
-                    let offset = if executable_format_version == 0 {
-                        47
+                // get arch
+                5 => {
+                    if cfg!(target_arch = "x86_64") {
+                        vm.registers[1] = hbvm::value::Value(0);
+                    } else if cfg!(target_arch = "aarch64") {
+                        vm.registers[1] = hbvm::value::Value(1);
                     } else {
-                        error!("Invalid executable format.");
-                        return;
+                        vm.registers[1] = hbvm::value::Value(u64::MAX)
+                    }
+                }
+                // AbleCode™ (get fb ptr)
+                6 => {
+                    use {
+                        crate::kmain::FB_REQ,
+                        limine::{Framebuffer, NonNullPtr},
                     };
-
-                    let code_length = u64::from_le_bytes(header[7..15].try_into().unwrap());
-                    let data_length = u64::from_le_bytes(header[15..23].try_into().unwrap());
-                    let end = (code_length + data_length) as usize;
-                    log::debug!("{code_length} + {data_length} = {end}");
-
-                    let thr = ExecThread::new(&program[offset..end], Address::new(0));
-                    vm.registers[1] = Value(
-                        LazyCell::<Executor>::get_mut(&mut EXECUTOR)
-                            .unwrap()
-                            .spawn(Box::pin(async move {
-                                if let Err(e) = thr.await {
-                                    log::error!("{e:?}");
-                                }
-                            })) as u64,
-                    );
-                    log::debug!("spawned a process");
-                },
-
+                    let fb1: &NonNullPtr<Framebuffer> =
+                        &FB_REQ.get_response().get().unwrap().framebuffers()[0];
+                    let msg = block_read(mem_addr, length)[0];
+                    if msg == b'p' {
+                        // ptr
+                        let fb_front = fb1.address.as_ptr().unwrap() as *const u8;
+                        log::info!("Graphics front ptr {:?}", fb_front);
+                        vm.registers[1] = hbvm::value::Value(fb_front as u64);
+                    } else if msg == b'w' {
+                        // width
+                        log::info!("FB Width: {}", fb1.width);
+                        vm.registers[1] = hbvm::value::Value(fb1.width);
+                    } else if msg == b'h' {
+                        // height
+                        log::info!("FB Height: {}", fb1.height);
+                        vm.registers[1] = hbvm::value::Value(fb1.height);
+                    }
+                }
                 buffer_id => {
                     let mut buffs = IPC_BUFFERS.lock();
                     match buffs.get_mut(&buffer_id) {
                         Some(buff) => {
-                            let msg_vec = block_read(mem_addr, length);
-                            buff.push(msg_vec.to_vec());
-                            debug!("Sent Message {:?} to Buffer({})", msg_vec, buffer_id);
+                            let mut msg_vec = Vec::with_capacity(length);
+
+                            for x in 0..(length as isize) {
+                                let xyz = mem_addr as *const u8;
+                                let value = unsafe { xyz.offset(x).read() };
+                                msg_vec.push(value);
+                            }
+                            debug!(
+                                "Message {:?} has been sent to Buffer({})",
+                                msg_vec, buffer_id
+                            );
+                            buff.push(msg_vec);
                         }
                         None => {
                             log::error!("Access of non-existent buffer {}", buffer_id)
                         }
                     }
+                    drop(buffs);
                 }
             }
         }
         4 => {
             let buffer_id = vm.registers[3].cast::<u64>();
-            let map_ptr = vm.registers[4].cast::<u64>();
+            let mut map_ptr = vm.registers[4].cast::<u64>();
             let max_length = vm.registers[5].cast::<u64>();
-            let mut buffs = IPC_BUFFERS.lock();
-            let buff: &mut IpcBuffer = match buffs.get_mut(&buffer_id) {
-                Some(buff) => buff,
-                None => panic!(
-                    "Failed to get buffer: id={buffer_id}, ptr={map_ptr}, length={max_length}"
-                ),
-            };
 
-            let msg = match buff.pop() {
-                Ok(msg) => msg,
-                Err(_) => return,
-            };
-            if msg.len() > unsafe { max_length.try_into().unwrap_unchecked() } {
+            let mut buffs = IPC_BUFFERS.lock();
+            let buff: &mut IpcBuffer;
+
+            if buffs.get_mut(&buffer_id).is_some() {
+                buff = buffs.get_mut(&buffer_id).unwrap();
+            } else {
+                // info!("AHHH");
+                vm.registers[1] = hbvm::value::Value(0);
+                return;
+            }
+            let pop = buff.pop();
+            if pop.is_err() {
+                return;
+            }
+            let msg = pop.unwrap();
+            if msg.len() > max_length.try_into().unwrap() {
                 info!("{}", max_length);
                 error!("Message is too long to map in.");
             } else {
                 unsafe {
-                    let ptr = map_ptr as *mut u8;
-                    ptr.copy_from_nonoverlapping(msg.as_ptr(), msg.len());
+                    let ptr: *mut u64 = &mut map_ptr;
+                    for (index, byte) in msg.iter().enumerate() {
+                        ptr.offset(index.try_into().unwrap()).write_bytes(*byte, 1);
+                    }
                 }
 
                 debug!("Recieve {:?} from Buffer({})", msg, buffer_id);
@@ -241,41 +255,65 @@ pub fn handler(vm: &mut Vm, pid: &usize) {
             #[cfg(target_arch = "x86_64")]
             {
                 let r2 = vm.registers[2].cast::<u64>();
-                let x = hbvm::value::Value(unsafe { x86_in::<u8>(r2 as u16) } as u64);
-                // info!("Read {:?} from Port {:?}", x, r2);
+                unsafe fn x86_in(address: u16) -> u32 {
+                    x86_64::instructions::port::Port::new(address).read()
+                }
+                unsafe fn x86_out(address: u16, value: u32) {
+                    x86_64::instructions::port::Port::new(address).write(value);
+                }
+                let x = hbvm::value::Value(unsafe { x86_in(r2 as u16) } as u64);
+                info!("Read {:?} from Port {:?}", x, r2);
                 vm.registers[3] = x
             }
         }
-        6 => {
-            // Wait till interrupt
-            use crate::kmain::EXECUTOR;
-            let interrupt_type = vm.registers[3].cast::<u8>();
-            debug!("Interrupt subscribed: {}", interrupt_type);
-            unsafe {
-                LazyCell::<Executor>::get_mut(&mut EXECUTOR)
-                    .unwrap()
-                    .interrupt_subscribe(*pid, interrupt_type);
-            }
-        }
-        7 => {
-            // Wait till buffer
-            use crate::kmain::EXECUTOR;
-            let buffer_id = vm.registers[3].cast::<u64>() as usize;
-            debug!("Buffer subscribed: {}", buffer_id);
-            unsafe {
-                LazyCell::<Executor>::get_mut(&mut EXECUTOR)
-                    .unwrap()
-                    .buffer_subscribe(*pid, buffer_id);
-            }
-        }
         _ => {
             log::error!("Syscall unknown {:?}{:?}", ecall_number, vm.registers);
         }
     }
 }
 
+fn log_msg_handler(_vm: &mut Vm, mem_addr: u64, length: usize) -> Result<(), LogError> {
+    // let message_length = 8 + 8 + 8;
+    // log::info!("Mem Addr 0x{:x?} length {}", mem_addr, length);
+    let msg_vec = block_read(mem_addr, length);
+
+    let log_level = msg_vec.last().unwrap();
+    match core::str::from_utf8(&msg_vec[1..]) {
+        Ok(strr) => {
+            // use LogLevel::*;
+            let _ll = match log_level {
+                0 | 48 => error!("{}", strr),
+                1 | 49 => warn!("{}", strr),
+                2 | 50 => info!("{}", strr),
+                3 | 51 => debug!("{}", strr),
+                4 | 52 => trace!("{}", strr),
+                _ => {
+                    return Err(LogError::InvalidLogFormat);
+                }
+            };
+        }
+        Err(e) => {
+            error!("{:?}", e);
+        }
+    }
+
+    Ok(())
+}
+
 #[derive(Debug)]
 pub enum LogError {
     NoMessages,
     InvalidLogFormat,
 }
+
+// use {alloc::vec, log::Record};
+// fn memory_msg_handler(vm: &mut Vm, mem_addr: u64, length: usize) -> Result<(), LogError> {
+//     let mut val = alloc::vec::Vec::new();
+//     for _ in 0..4096 {
+//         val.push(0);
+//     }
+//     info!("Block address: {:?}", val.as_ptr());
+//     vm.registers[1] = hbvm::value::Value(val.as_ptr() as u64);
+//     vm.registers[2] = hbvm::value::Value(4096);
+//     Ok(())
+// }

kernel/src/holeybytes/kernel_services/dt_msg_handler.rs

@@ -1,78 +0,0 @@
-use {
-    crate::holeybytes::{kernel_services::block_read, Vm},
-    alloc::vec::Vec,
-};
-pub enum DtError {
-    QueryFailure,
-}
-
-pub fn dt_msg_handler(vm: &mut Vm, mem_addr: u64, length: usize) -> Result<(), DtError> {
-    let msg_vec = block_read(mem_addr, length);
-    let query_string = core::str::from_utf8(
-        msg_vec
-            .split_once(|&byte| byte == 0)
-            .unwrap_or((msg_vec, &[]))
-            .0,
-    )
-    .unwrap();
-    log::trace!("Query {}", query_string);
-
-    let ret = query_parse(query_string);
-    log::trace!("Query response {}", ret);
-
-    vm.registers[1] = hbvm::value::Value(ret);
-
-    Ok(())
-}
-
-fn query_parse(query_string: &str) -> u64 {
-    let query = query_string.split('/').collect::<Vec<&str>>();
-
-    let first_fragment: &str = &query[0];
-    let ret = match first_fragment {
-        "framebuffer" => framebuffer_parse(query),
-        "cpu" => cpu_parse(query),
-
-        _ => 0,
-    };
-
-    return ret;
-}
-
-fn cpu_parse(qt_parse_step_two: Vec<&str>) -> u64 {
-    let second_fragment: &str = qt_parse_step_two[1];
-    match second_fragment {
-        // "architecture" => {
-        //     return 0;
-        // }
-        _ => {
-            return 0;
-        }
-    };
-}
-
-fn framebuffer_parse(qt_parse_step_two: Vec<&str>) -> u64 {
-    use crate::kmain::FB_REQ;
-    let fbs = &mut FB_REQ.get_response().get().unwrap().framebuffers();
-    let second_fragment: &str = qt_parse_step_two[1];
-    match second_fragment {
-        "fb0" => {
-            let fb_front = &fbs[0];
-            let third_fragment: &str = qt_parse_step_two[2];
-            let ret = match third_fragment {
-                "ptr" => {
-                    let ptr = fb_front.address.as_ptr().unwrap();
-                    ptr as usize as u64
-                }
-                "width" => fb_front.width,
-                "height" => fb_front.height,
-
-                _ => 0,
-            };
-            return ret;
-        }
-        _ => {
-            return 0;
-        }
-    };
-}

kernel/src/holeybytes/kernel_services/logging_service.rs

@@ -1,54 +0,0 @@
-use crate::holeybytes::{kernel_services::block_read, Vm};
-
-#[derive(Debug)]
-pub enum LogError {
-    InvalidLogFormat,
-}
-use log::Record;
-
-pub fn log_msg_handler(_vm: &mut Vm, mem_addr: u64, length: usize) -> Result<(), LogError> {
-    let msg_vec = block_read(mem_addr, length);
-
-    use log::Level::*;
-    let log_level = match msg_vec[0] {
-        0 | 48 => Error,
-        1 | 49 => Warn,
-        2 | 50 => Info,
-        3 | 51 => Debug,
-        4 | 52 => Trace,
-        _ => {
-            return Err(LogError::InvalidLogFormat);
-        }
-    };
-    if log_level > log::max_level() {
-        return Ok(());
-    }
-    let strptr = u64::from_le_bytes(msg_vec[1..9].try_into().unwrap());
-    let strlen = u64::from_le_bytes(msg_vec[9..17].try_into().unwrap()) as usize;
-
-    let str = block_read(strptr, strlen);
-
-    let file_name = "None";
-    let line_number = 0;
-
-    match core::str::from_utf8(&str) {
-        Ok(strr) => {
-            log::logger().log(
-                &Record::builder()
-                    .args(format_args!("{}", strr))
-                    .level(log_level)
-                    .target("Userspace")
-                    .file(Some(file_name))
-                    .line(Some(line_number))
-                    .module_path(Some(&file_name))
-                    .build(),
-            );
-        }
-
-        Err(e) => {
-            log::error!("{:?}", e);
-        }
-    }
-
-    Ok(())
-}

kernel/src/holeybytes/kernel_services/mem_serve.rs

@@ -1,6 +1,6 @@
 use {
     crate::holeybytes::{kernel_services::block_read, Vm},
-    alloc::alloc::{alloc, dealloc},
+    alloc::alloc::{alloc_zeroed, dealloc},
     core::alloc::Layout,
     log::{debug, info},
 };
@@ -17,28 +17,13 @@ pub enum MemoryQuotaType {
 }
 
 fn alloc_page(vm: &mut Vm, _mem_addr: u64, _length: usize) -> Result<(), MemoryServiceError> {
-    let ptr = unsafe { alloc(Layout::from_size_align_unchecked(4096, 8)) };
+    let ptr = unsafe { alloc_zeroed(Layout::new::<[u8; 4096]>()) };
     info!("Block address: {:?}", ptr);
     vm.registers[1] = hbvm::value::Value(ptr as u64);
     vm.registers[2] = hbvm::value::Value(4096);
     Ok(())
 }
 
-#[inline(always)]
-unsafe fn memset(dest: *mut u8, src: *const u8, count: usize, size: usize) {
-    let total_size = count * size;
-    src.copy_to_nonoverlapping(dest, size);
-
-    let mut copied = size;
-
-    while copied < total_size {
-        let copy_size = copied.min(total_size - copied);
-        dest.add(copied).copy_from_nonoverlapping(dest, copy_size);
-        copied += copy_size;
-    }
-}
-
-#[inline(always)]
 pub fn memory_msg_handler(
     vm: &mut Vm,
     mem_addr: u64,
@@ -47,35 +32,40 @@ pub fn memory_msg_handler(
     let msg_vec = block_read(mem_addr, length);
     let msg_type = msg_vec[0];
     match msg_type {
-        0 => unsafe {
+        0 => {
             let page_count = msg_vec[1];
+            let mptr_raw: [u8; 8] = msg_vec[2..10].try_into().unwrap();
+            let mptr: u64 = u64::from_le_bytes(mptr_raw);
 
-            let ptr = alloc(Layout::from_size_align_unchecked(
-                page_count as usize * 4096,
-                8,
-            ));
+            log::debug!("Allocating {} pages @ {:x}", page_count, mptr);
 
-            log::debug!("Allocating {} pages @ {:x}", page_count, ptr as u64);
+            let ptr = unsafe {
+                alloc_zeroed(Layout::from_size_align_unchecked(
+                    page_count as usize * 4096,
+                    1,
+                ))
+            };
 
             vm.registers[1] = hbvm::value::Value(ptr as u64);
             log::debug!("Kernel ptr: {:x}", ptr as u64);
-        },
+        }
 
-        1 => unsafe {
+        1 => {
             let page_count = msg_vec[1];
 
             let mptr_raw: [u8; 8] = msg_vec[2..10].try_into().unwrap();
             let mptr: u64 = u64::from_le_bytes(mptr_raw);
             log::debug!("Deallocating {} pages @ {:x}", page_count, mptr);
-
-            dealloc(
-                mptr as *mut u8,
-                Layout::from_size_align_unchecked(page_count as usize * 4096, 8),
-            )
-        },
+            unsafe {
+                dealloc(
+                    mptr as *mut u8,
+                    Layout::from_size_align_unchecked(page_count as usize * 4096, 1),
+                )
+            }
+        }
         2 => {
             use MemoryQuotaType::*;
-            let quota_type = match msg_vec[1] {
+            let quota_type = match msg_vec[0] {
                 0 => NoQuota,
                 1 => SoftQuota,
                 2 => HardQuota,
@@ -92,27 +82,10 @@ pub fn memory_msg_handler(
             )
         }
         3 => {
-            let page_count = msg_vec[1];
+            let page_count = msg_vec[0];
             log::debug!(" {} pages", page_count);
         }
-        4 => unsafe {
-            let count = u64::from_le_bytes(msg_vec[1..9].try_into().unwrap_unchecked()) as usize;
-            let src = u64::from_le_bytes(msg_vec[9..17].try_into().unwrap_unchecked()) as *const u8;
-            let dest = u64::from_le_bytes(msg_vec[17..25].try_into().unwrap_unchecked()) as *mut u8;
-            debug_assert!(src.addr() & 0xFFFF000000000000 != 0);
-            debug_assert!(dest.addr() & 0xFFFF000000000000 != 0);
-            src.copy_to_nonoverlapping(dest, count);
-        },
-        5 => unsafe {
-            let count = u64::from_le_bytes(msg_vec[1..9].try_into().unwrap_unchecked()) as usize;
-            let size = u64::from_le_bytes(msg_vec[9..17].try_into().unwrap_unchecked()) as usize;
-            let src =
-                u64::from_le_bytes(msg_vec[17..25].try_into().unwrap_unchecked()) as *const u8;
-            let dest = u64::from_le_bytes(msg_vec[25..33].try_into().unwrap_unchecked()) as *mut u8;
-            debug_assert!(src.addr() & 0xFFFF000000000000 != 0);
-            debug_assert!(dest.addr() & 0xFFFF000000000000 != 0);
-            memset(dest, src, count, size);
-        },
+
         _ => {
             log::debug!("Unknown memory service message type: {}", msg_type);
         }

kernel/src/holeybytes/kernel_services/mod.rs

@@ -1,11 +1,9 @@
 use core::slice;
 
-pub mod dt_msg_handler;
-pub mod logging_service;
 pub mod mem_serve;
 pub mod service_definition_service;
 
 #[inline(always)]
-pub fn block_read<'a>(mem_addr: u64, length: usize) -> &'a mut [u8] {
-    unsafe { slice::from_raw_parts_mut(mem_addr as *mut _, length) }
+pub fn block_read<'a>(mem_addr: u64, length: usize) -> &'a [u8] {
+    unsafe { slice::from_raw_parts(mem_addr as *const u8, length) }
 }

kernel/src/holeybytes/kernel_services/service_definition_service.rs

@@ -1,7 +1,7 @@
 use {
     crate::{
         arch::hardware_random_u64,
-        holeybytes::{kernel_services::block_read, Vm},
+        holeybytes::{ecah::LogError, kernel_services::block_read, Vm},
         ipc::{buffer::IpcBuffer, protocol::Protocol},
         kmain::IPC_BUFFERS,
     },
@@ -15,26 +15,28 @@ pub static SERVICES: Lazy<Mutex<Services>> = Lazy::new(|| {
     dt.0.insert(0, Protocol::void());
     Mutex::new(dt)
 });
-#[derive(Debug)]
-pub enum ServiceError {
-    InvalidFormat,
-}
-pub fn sds_msg_handler(vm: &mut Vm, mem_addr: u64, length: usize) -> Result<(), ServiceError> {
+
+pub fn sds_msg_handler(vm: &mut Vm, mem_addr: u64, length: usize) -> Result<(), LogError> {
     let msg_vec = block_read(mem_addr, length);
+    if msg_vec.is_empty() {
+        return Err(LogError::NoMessages);
+    }
     let sds_event_type: ServiceEventType = msg_vec[0].into();
-    let strptr = u64::from_le_bytes(msg_vec[1..9].try_into().unwrap());
-    let strlen = u64::from_le_bytes(msg_vec[9..17].try_into().unwrap()) as usize;
-    let string_vec = block_read(strptr, strlen);
-    let string = core::str::from_utf8(string_vec).expect("Our bytes should be valid utf8");
+
+    // info!("Length {}", msg_vec.len());
 
     use ServiceEventType::*;
     match sds_event_type {
         CreateService => {
+            let string =
+                core::str::from_utf8(&msg_vec[1..]).expect("Our bytes should be valid utf8");
             let ret = sds_create_service(string);
             vm.registers[1] = hbvm::value::Value(ret as u64);
         }
         DeleteService => todo!(),
         SearchServices => {
+            let string =
+                core::str::from_utf8(&msg_vec[1..]).expect("Our bytes should be valid utf8");
             let ret = sds_search_service(string);
             vm.registers[1] = hbvm::value::Value(ret as u64);
         }
@@ -92,7 +94,8 @@ fn sds_create_service(protocol: &'static str) -> u64 {
     // let a: protocol::Protocol = protocol.into();
     buff_id
 }
-pub fn sds_search_service(protocol: &str) -> u64 {
+
+fn sds_search_service(protocol: &str) -> u64 {
     let services = SERVICES.lock();
     let compare = Protocol::from(protocol);
     for (bid, protocol_canidate) in &services.0 {

kernel/src/holeybytes/mem.rs

@@ -30,29 +30,30 @@ impl Memory {
 }
 
 impl hbvm::mem::Memory for Memory {
-    #[inline(always)]
+    #[inline]
     unsafe fn load(
         &mut self,
         addr: Address,
         target: *mut u8,
         count: usize,
     ) -> Result<(), hbvm::mem::LoadError> {
-        core::ptr::copy_nonoverlapping(addr.get() as *const u8, target, count);
+        if addr.get() % 4096 == 0 {}
+        core::ptr::copy(addr.get() as *const u8, target, count);
         Ok(())
     }
 
-    #[inline(always)]
+    #[inline]
     unsafe fn store(
         &mut self,
         addr: Address,
         source: *const u8,
         count: usize,
     ) -> Result<(), hbvm::mem::StoreError> {
-        core::ptr::copy_nonoverlapping(source, addr.get() as *mut u8, count);
+        core::ptr::copy(source, addr.get() as *mut u8, count);
         Ok(())
     }
 
-    #[inline(always)]
+    #[inline]
     unsafe fn prog_read<T: Copy>(&mut self, addr: Address) -> T {
         (addr.get() as *const T).read()
     }

kernel/src/holeybytes/mod.rs

@@ -1,9 +1,9 @@
 mod ecah;
-pub mod kernel_services;
+mod kernel_services;
 mod mem;
 
 use {
-    alloc::alloc::{alloc, dealloc},
+    alloc::alloc::{alloc_zeroed, dealloc},
     core::{
         alloc::Layout,
         future::Future,
@@ -61,27 +61,28 @@ impl<'p> Future for ExecThread {
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         match self.vm.run() {
             Err(err) => {
-                log::error!("HBVM Error\r\nRegister dump: {:?}", self.vm.registers,);
-                return Poll::Ready(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
             }
-            Ok(VmRunOk::End) => return Poll::Ready(Ok(())),
-            Ok(VmRunOk::Ecall) => ecah::handler(
-                &mut self.vm,
-                cx.ext()
-                    .downcast_ref()
-                    .expect("PID did not exist in Context"),
-            ),
-            Ok(VmRunOk::Timer) => (),
             Ok(VmRunOk::Breakpoint) => {
-                log::error!(
+                error!(
                     "HBVM Debug breakpoint\r\nRegister dump: {:?}",
-                    self.vm.registers,
+                    self.vm.registers
                 );
+                cx.waker().wake_by_ref();
+                Poll::Pending
             }
         }
-
-        cx.waker().wake_by_ref();
-        Poll::Pending
     }
 }
 
@@ -102,10 +103,10 @@ impl HandlePageFault for PageFaultHandler {
 
 #[inline(always)]
 const fn stack_layout() -> Layout {
-    unsafe { Layout::from_size_align_unchecked(STACK_SIZE, 8) }
+    unsafe { Layout::from_size_align_unchecked(STACK_SIZE, 4096) }
 }
 
 #[inline(always)]
 fn allocate_stack() -> *mut u8 {
-    unsafe { alloc(stack_layout()) }
+    unsafe { alloc_zeroed(stack_layout()) }
 }

kernel/src/ipc/buffer.rs

@@ -49,7 +49,9 @@ impl<'a> IpcBuffer<'a> {
     pub fn push(&mut self, msg: Message) {
         match &self.buffer {
             BufferTypes::Unbound(buff) => buff.push(msg),
-            BufferTypes::Bound(buff) => buff.push(msg).unwrap(),
+            BufferTypes::Bound(buff) => {
+                let _ = buff.push(msg);
+            }
         };
     }
     pub fn pop(&mut self) -> Result<Message, IpcError> {

kernel/src/ipc/protocol.rs

@@ -1,15 +1,18 @@
-use {alloc::vec::Vec, hashbrown::HashMap};
+use {
+    alloc::{string::String, vec::Vec},
+    hashbrown::HashMap,
+};
 #[derive(Debug, PartialEq, Clone)]
 pub struct Type {}
 #[derive(Debug, PartialEq, Clone)]
-pub struct Funct<'a> {
-    takes: Vec<&'a str>,
-    gives: Vec<&'a str>,
+pub struct Funct {
+    takes: Vec<String>,
+    gives: Vec<String>,
 }
 #[derive(Debug, PartialEq, Clone)]
 pub struct Protocol<'a> {
     types: HashMap<&'a str, Type>,
-    fns:   HashMap<&'a str, Funct<'a>>,
+    fns:   HashMap<&'a str, Funct>,
 }
 impl<'a> Protocol<'a> {
     pub fn void() -> Self {

kernel/src/kmain.rs

@@ -8,32 +8,17 @@ use {
         device_tree::DeviceTree,
         holeybytes::ExecThread,
         ipc::buffer::IpcBuffer,
-        task::Executor,
     },
-    alloc::boxed::Box,
-    core::cell::LazyCell,
     hashbrown::HashMap,
     hbvm::mem::Address,
     limine::{Framebuffer, FramebufferRequest, NonNullPtr},
-    log::{debug, error, trace},
+    log::{debug, info},
     spin::{Lazy, Mutex},
 };
 
 pub fn kmain(_cmdline: &str, boot_modules: BootModules) -> ! {
     debug!("Entered kmain");
 
-    #[cfg(feature = "ktest")]
-    {
-        use {
-			crate::ktest,
-			log::info,
-		};
-        info!("Running tests");
-        ktest::test_main();
-
-        loop {}
-    }
-
     // let kcmd = build_cmd("Kernel Command Line", cmdline);
     // trace!("Cmdline: {kcmd:?}");
 
@@ -51,9 +36,9 @@ pub fn kmain(_cmdline: &str, boot_modules: BootModules) -> ! {
     let dt = DEVICE_TREE.lock();
 
     // TODO(Able): This line causes a deadlock
-    debug!("Device Tree: {}", dt);
+    info!("Device Tree: {}", dt);
 
-    trace!("Boot complete. Moving to init_system");
+    info!("Boot complete. Moving to init_system");
 
     // TODO: schedule the disk driver from the initramfs
     // TODO: schedule the filesystem driver from the initramfs
@@ -65,84 +50,56 @@ pub fn kmain(_cmdline: &str, boot_modules: BootModules) -> ! {
     let fb1: &NonNullPtr<Framebuffer> = &FB_REQ.get_response().get().unwrap().framebuffers()[0];
 
     {
+        use crate::alloc::string::ToString;
         let mut dt = DEVICE_TREE.lock();
         let mut disp = xml::XMLElement::new("display_0");
 
         disp.set_attribute("width", fb1.width);
         disp.set_attribute("height", fb1.height);
-        disp.set_attribute("bpp", fb1.bpp);
+        disp.set_attribute("bits per pixel", fb1.bpp);
         disp.set_attribute("pitch", fb1.pitch);
-        dt.devices.insert("Displays", alloc::vec![disp]);
+        dt.devices.insert("Displays".to_string(), alloc::vec![disp]);
     }
-    debug!("Graphics initialised");
-    debug!(
+    log::info!("Graphics initialised");
+    log::info!(
         "Graphics front ptr {:?}",
         fb1.address.as_ptr().unwrap() as *const u8
     );
-    log::info!("Started AbleOS");
 
+    let mut executor = crate::task::Executor::new(256);
+    let bm_take = boot_modules.len();
     unsafe {
-        let executor = LazyCell::<Executor>::force_mut(&mut EXECUTOR);
-        for module in boot_modules.iter() {
-            let cmd = module.cmd.trim_matches('"');
+        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()]
+            }
             let cmd_len = cmd.len() as u64;
 
-            log::info!(
-                "Starting {}",
-                module
-                    .path
-                    .split('/')
-                    .last()
-                    .unwrap()
-                    .split('.')
-                    .next()
-                    .unwrap()
-            );
-            log::debug!("Spawning {} with arguments \"{}\"", module.path, cmd);
+            log::info!("Spawning {} with arguments \"{}\"", module.path, cmd);
 
-            // decode AbleOS Executable format
-            let header = &module.bytes[0..46];
-            let magic_slice = &header[0..3];
-            if magic_slice != [0x15, 0x91, 0xD2] {
-                log::error!("Invalid magic number at the start of executable.");
-                continue;
-            }
-
-            let executable_format_version = u32::from_le_bytes(header[3..7].try_into().unwrap());
-            let offset = if executable_format_version == 0 {
-                47
-            } else {
-                error!("Invalid executable format.");
-                continue;
-            };
-
-            let code_length = u64::from_le_bytes(header[7..15].try_into().unwrap());
-            let data_length = u64::from_le_bytes(header[15..23].try_into().unwrap());
-            let end = (code_length + data_length) as usize;
-            log::debug!("{code_length} + {data_length} = {end}");
-
-            let mut thr = ExecThread::new(&module.bytes[offset..end], Address::new(0));
-            if cmd_len > 0 {
-                thr.set_arguments(cmd.as_ptr() as u64, cmd_len);
-            }
-            executor.spawn(Box::pin(async {
+            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);
+                }
                 if let Err(e) = thr.await {
                     log::error!("{e:?}");
                 }
-            }));
+            })
         }
 
-        debug!("Random number: {}", hardware_random_u64());
+        info!("Random number: {}", hardware_random_u64());
 
         executor.run();
     };
+
     crate::arch::spin_loop()
 }
 
-// ! SAFETY: this is not threadsafe at all, like even a little bit.
-// ! SERIOUSLY
-pub static mut EXECUTOR: LazyCell<Executor> = LazyCell::new(|| Executor::new());
-
 pub static DEVICE_TREE: Lazy<Mutex<DeviceTree>> = Lazy::new(|| {
     let dt = DeviceTree::new();
     Mutex::new(dt)
@@ -160,3 +117,10 @@ pub static IPC_BUFFERS: Lazy<Mutex<IpcBuffers>> = Lazy::new(|| {
 
     Mutex::new(bufs)
 });
+
+#[test_case]
+fn trivial_assertion() {
+    trace!("trivial assertion... ");
+    assert_eq!(1, 1);
+    info!("[ok]");
+}

kernel/src/ktest.rs

@@ -1,51 +0,0 @@
-pub use ktest_macro::*;
-
-use {
-	alloc::string::String,
-	log::{error, info},
-};
-
-extern "C" {
-    static __ktest_start: fn() -> Result<String, String>;
-    static __ktest_end: fn() -> Result<String, String>;
-}
-
-// TODO: Implement ktest for arm and riscv (Later problems, see below)
-//       Allow for arch specific tests (Leave for now)
-//       Should panic tests
-//       Test specific panic handler
-pub fn test_main() {
-    unsafe {
-        let mut current_test = &__ktest_start as *const fn() -> Result<String, String>;
-        let test_end = &__ktest_end as *const fn() -> Result<String, String>;
-
-		let mut pass = 0;
-		let mut fail = 0;
-
-        while current_test < test_end {
-            let test_fn = *current_test;
-
-            let test_name = test_fn();
-            match test_name {
-                Ok(name) => {
-                    info!("Test: {} passed", name);
-                    pass += 1;
-                },
-                Err(name) => {
-                    error!("Test: {} failed", name);
-                    fail += 1;
-                }
-            }
-
-            current_test = current_test.add(1);
-        }
-
-        info!("{}/{} tests passed", pass, pass + fail);
-    }
-}
-
-#[ktest]
-pub fn trivial_assertion() {
-    ktest_eq!(1, 1);
-	ktest_neq!(0, 1);
-}

kernel/src/lib.rs

@@ -2,21 +2,18 @@
 //! 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]
-#![no_main]
+#![feature(new_uninit)]
 #![feature(
-    slice_split_once,
-    exclusive_wrapper,
-    core_intrinsics,
     abi_x86_interrupt,
-    lazy_get,
     alloc_error_handler,
-    local_waker,
-    context_ext,
     ptr_sub_ptr,
+    custom_test_frameworks,
     naked_functions,
     pointer_is_aligned_to
 )]
-#![allow(dead_code, internal_features, static_mut_refs)]
+#![test_runner(crate::test_runner)]
+#![cfg_attr(not(debug_assertions), allow(unused, deprecated))]
+#![allow(dead_code)]
 extern crate alloc;
 
 mod allocator;
@@ -24,7 +21,6 @@ mod arch;
 mod bootmodules;
 mod capabilities;
 mod device_tree;
-mod exe_format;
 mod handle;
 mod holeybytes;
 mod ipc;
@@ -34,9 +30,6 @@ mod memory;
 mod task;
 mod utils;
 
-#[allow(improper_ctypes, non_upper_case_globals)]
-mod ktest;
-
 use versioning::Version;
 
 /// Kernel's version
@@ -49,7 +42,6 @@ pub const VERSION: Version = Version {
 #[panic_handler]
 #[cfg(target_os = "none")]
 fn panic(info: &core::panic::PanicInfo) -> ! {
-    use alloc::string::ToString;
     arch::register_dump();
 
     if let Some(loc) = info.location() {
@@ -61,7 +53,15 @@ fn panic(info: &core::panic::PanicInfo) -> ! {
         ));
     }
 
-    let msg = info.message().to_string().replace("\n", "\r\n");
+    let msg = info.message();
     let _ = crate::arch::log(format_args!("{msg}\r\n"));
     loop {}
 }
+
+#[cfg(test)]
+fn test_runner(tests: &[&dyn Fn()]) {
+    println!("Running {} tests", tests.len());
+    for test in tests {
+        test();
+    }
+}

kernel/src/logger.rs

@@ -36,26 +36,13 @@ impl log::Log for Logger {
             Level::Debug => "25",
             Level::Trace => "103",
         };
-        let module = record
-            .module_path()
-            .unwrap_or_default()
-            .rsplit_once(':')
-            .unwrap_or_default()
-            .1;
-        if module == "" {
-            crate::arch::log(format_args!(
-                "\x1b[38;5;{lvl_color}m{lvl}\x1b[0m: {}\r\n",
-                record.args(),
-            ))
-            .expect("write to serial console");
-        } else {
-            let line = record.line().unwrap_or_default();
-            crate::arch::log(format_args!(
-                "\x1b[38;5;{lvl_color}m{lvl}\x1b[0m [{module}:{line}]: {}\r\n",
-                record.args(),
-            ))
-            .expect("write to serial console");
-        }
+        let module = record.module_path().unwrap_or_default();
+        let line = record.line().unwrap_or_default();
+        crate::arch::log(format_args!(
+            "\x1b[38;5;{lvl_color}m{lvl}\x1b[0m [{module}:{line}]: {}\r\n",
+            record.args(),
+        ))
+        .expect("write to serial console");
     }
 
     fn flush(&self) {}

kernel/src/task.rs

@@ -1,14 +1,9 @@
 use {
-    alloc::{
-        boxed::Box,
-        collections::{BTreeMap, BTreeSet},
-        sync::Arc,
-    },
+    alloc::{boxed::Box, sync::Arc},
     core::{
         future::Future,
         pin::Pin,
-        sync::atomic::{AtomicBool, Ordering},
-        task::{Context, ContextBuilder, Poll, RawWaker, RawWakerVTable, Waker},
+        task::{Context, Poll, RawWaker, RawWakerVTable, Waker},
     },
     crossbeam_queue::SegQueue,
     slab::Slab,
@@ -19,6 +14,7 @@ pub fn yield_now() -> impl Future<Output = ()> {
     impl Future for YieldNow {
         type Output = ();
 
+        #[inline(always)]
         fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
             if self.0 {
                 Poll::Ready(())
@@ -33,184 +29,150 @@ pub fn yield_now() -> impl Future<Output = ()> {
     YieldNow(false)
 }
 
-pub trait Process: Future<Output = ()> + Send {}
-impl<T: Future<Output = ()> + Send> Process for T {}
-
-pub struct Executor {
-    tasks: Slab<Task>,
-    task_queue: Arc<SegQueue<usize>>,
-    interrupt_lookup: [Option<usize>; u8::MAX as usize],
-    buffer_lookup: BTreeMap<usize, BTreeSet<usize>>,
+pub struct Executor<F: Future<Output = ()> + Send> {
+    tasks:      Slab<Task<F>>,
+    task_queue: Arc<TaskQueue>,
 }
 
-impl Executor {
-    pub fn new() -> Self {
+impl<F: Future<Output = ()> + Send> Executor<F> {
+    pub fn new(size: usize) -> Self {
         Self {
-            tasks: Slab::new(),
-            task_queue: Arc::new(SegQueue::new()),
-            interrupt_lookup: [None; u8::MAX as usize],
-            buffer_lookup: BTreeMap::new(),
+            tasks:      Slab::with_capacity(size),
+            task_queue: Arc::new(TaskQueue::new()),
         }
     }
 
-    pub fn spawn(&mut self, future: Pin<Box<dyn Process>>) -> usize {
-        let id = self.tasks.insert(Task::new(future));
-        self.task_queue.push(id);
-
-        id
-    }
-
-    pub fn pause(&self, id: usize) {
-        if let Some(task) = self.tasks.get(id) {
-            task.set_paused(true);
-        }
-    }
-
-    pub fn unpause(&self, id: usize) {
-        if let Some(task) = self.tasks.get(id) {
-            task.set_paused(false);
-            self.task_queue.push(id);
-        }
-    }
-
-    pub fn interrupt_subscribe(&mut self, pid: usize, interrupt_type: u8) {
-        self.pause(pid);
-        self.interrupt_lookup[interrupt_type as usize] = Some(pid);
-    }
-
-    pub fn buffer_subscribe(&mut self, pid: usize, buffer_id: usize) {
-        self.pause(pid);
-        if let Some(buf) = self.buffer_lookup.get_mut(&buffer_id) {
-            buf.insert(pid);
-        } else {
-            self.buffer_lookup.insert(buffer_id, BTreeSet::from([pid]));
-        }
+    #[inline]
+    pub fn spawn(&mut self, future: F) {
+        self.task_queue
+            .queue
+            .push(self.tasks.insert(Task::new(future)));
     }
 
     pub fn run(&mut self) {
         let mut task_batch = [0; 32];
-        loop {
-            let mut batch_len = 0;
+        let mut batch_len = 0;
 
-            while let Some(id) = self.task_queue.pop() {
-                task_batch[batch_len] = id;
-                batch_len += 1;
-                if batch_len == task_batch.len() {
+        loop {
+            self.task_queue.batch_pop(&mut task_batch, &mut batch_len);
+
+            if batch_len == 0 {
+                if self.task_queue.is_empty() {
                     break;
+                } else {
+                    continue;
                 }
             }
 
-            if batch_len == 0 {
-                // break;
-                continue;
-            }
-
-            for &(mut id) in &task_batch[..batch_len] {
+            for &id in &task_batch[..batch_len] {
                 if let Some(task) = self.tasks.get_mut(id) {
-                    if task.is_paused() {
-                        continue;
-                    }
+                    let waker = task
+                        .waker
+                        .get_or_insert_with(|| TaskWaker::new(id, Arc::clone(&self.task_queue)));
 
-                    let waker = create_waker(id, Arc::clone(&self.task_queue));
-                    let mut cx = ContextBuilder::from_waker(&waker).ext(&mut id).build();
+                    let waker = unsafe { Waker::from_raw(TaskWaker::into_raw_waker(waker)) };
+                    let mut cx = Context::from_waker(&waker);
 
                     if let Poll::Ready(()) = task.poll(&mut cx) {
                         self.tasks.remove(id);
-                        self.interrupt_lookup.map(|pid| {
-                            if let Some(pid) = pid {
-                                if pid == id {
-                                    return None;
-                                }
-                            }
-                            return pid;
-                        });
-                        self.buffer_lookup.iter_mut().for_each(|(_, pid_set)| {
-                            pid_set.remove(&id);
-                        });
+                        self.task_queue.free_tasks.push(id);
                     }
                 }
             }
         }
     }
-
-    pub fn send_interrupt(&self, interrupt: u8) {
-        let id = self.interrupt_lookup[interrupt as usize];
-        if let Some(id) = id {
-            self.unpause(id);
-        }
-    }
-    pub fn send_buffer(&self, id: usize) {
-        if let Some(buf) = self.buffer_lookup.get(&id) {
-            buf.iter().for_each(|pid| self.unpause(*pid));
-        }
-    }
 }
 
-struct Task {
-    future: Pin<Box<dyn Process>>,
-    paused: AtomicBool,
+struct Task<F: Future<Output = ()> + Send> {
+    future: Pin<Box<F>>,
+    waker:  Option<TaskWaker>,
 }
 
-impl Task {
-    fn new(future: Pin<Box<dyn Process>>) -> Self {
+impl<F: Future<Output = ()> + Send> Task<F> {
+    #[inline(always)]
+    pub fn new(future: F) -> Self {
         Self {
-            future,
-            paused: AtomicBool::new(false),
+            future: Box::pin(future),
+            waker:  None,
         }
     }
 
+    #[inline(always)]
     fn poll(&mut self, cx: &mut Context) -> Poll<()> {
         self.future.as_mut().poll(cx)
     }
-
-    fn is_paused(&self) -> bool {
-        self.paused.load(Ordering::Acquire)
-    }
-
-    fn set_paused(&self, paused: bool) {
-        self.paused.store(paused, Ordering::Release)
-    }
 }
 
-fn create_waker(task_id: usize, task_queue: Arc<SegQueue<usize>>) -> Waker {
-    let data = Box::new(TaskWaker {
-        task_id,
-        task_queue,
-    });
-    let raw_waker = RawWaker::new(Box::into_raw(data) as *const (), &VTABLE);
-    unsafe { Waker::from_raw(raw_waker) }
-}
-
-#[derive(Clone)]
 struct TaskWaker {
-    task_id:    usize,
-    task_queue: Arc<SegQueue<usize>>,
+    id: usize,
+    task_queue: Arc<TaskQueue>,
 }
 
 impl TaskWaker {
+    #[inline(always)]
+    fn new(id: usize, task_queue: Arc<TaskQueue>) -> Self {
+        Self { id, task_queue }
+    }
+
+    #[inline(always)]
     fn wake(&self) {
-        self.task_queue.push(self.task_id);
+        self.task_queue.queue.push(self.id);
+    }
+
+    fn into_raw_waker(waker: &TaskWaker) -> RawWaker {
+        let ptr = waker as *const TaskWaker;
+        RawWaker::new(ptr.cast(), &VTABLE)
     }
 }
 
 const VTABLE: RawWakerVTable = RawWakerVTable::new(clone_raw, wake_raw, wake_by_ref_raw, drop_raw);
 
 unsafe fn clone_raw(ptr: *const ()) -> RawWaker {
-    let task_waker = Box::from_raw(ptr as *mut TaskWaker);
-    let raw_waker = RawWaker::new(Box::into_raw(task_waker.clone()) as *const (), &VTABLE);
-    raw_waker
+    let waker = &*(ptr as *const TaskWaker);
+    TaskWaker::into_raw_waker(waker)
 }
 
 unsafe fn wake_raw(ptr: *const ()) {
-    let task_waker = Box::from_raw(ptr as *mut TaskWaker);
-    task_waker.wake();
+    let waker = &*(ptr as *const TaskWaker);
+    waker.wake();
 }
 
 unsafe fn wake_by_ref_raw(ptr: *const ()) {
-    let task_waker = &*(ptr as *const TaskWaker);
-    task_waker.wake();
+    let waker = &*(ptr as *const TaskWaker);
+    waker.wake();
 }
 
-unsafe fn drop_raw(ptr: *const ()) {
-    drop(Box::from_raw(ptr as *mut TaskWaker));
+unsafe fn drop_raw(_: *const ()) {}
+
+struct TaskQueue {
+    queue:      SegQueue<usize>,
+    next_task:  usize,
+    free_tasks: SegQueue<usize>,
+}
+
+impl TaskQueue {
+    fn new() -> Self {
+        Self {
+            queue:      SegQueue::new(),
+            next_task:  0,
+            free_tasks: SegQueue::new(),
+        }
+    }
+
+    #[inline(always)]
+    fn batch_pop(&self, output: &mut [usize], len: &mut usize) {
+        *len = 0;
+        while let Some(id) = self.queue.pop() {
+            output[*len] = id;
+            *len += 1;
+            if *len == output.len() {
+                break;
+            }
+        }
+    }
+
+    #[inline(always)]
+    fn is_empty(&self) -> bool {
+        self.queue.is_empty()
+    }
 }

kernel/src/utils.rs

@@ -4,14 +4,15 @@
 /// Used when tab `\t` in hardware is not known and we will default to two spaces
 pub const TAB: &str = "  ";
 
+
 // NOTE: this only reduces the code duplication in source code not in generated code!
 // Written by Yours Truly: Munir
 /// A simple macro to reduce code duplication when we use TAB internally
 #[macro_export]
 macro_rules! tab {
-    ($num:expr) => {
+    ($num:expr) => { 
         TAB.repeat($num)
-    };
+    }
 }
 
 // NOTE: this only reduces the code duplication in source code not in generated code!
@@ -21,7 +22,7 @@ macro_rules! tab {
 macro_rules! device_tree {
     ($devtree:expr, $dev_type_vec:expr) => {
         for each_device_type in $dev_type_vec {
-            $devtree.devices.insert(each_device_type, Vec::new());
+            $devtree.devices.insert(each_device_type.to_string(), Vec::new());
         }
     };
 }
@@ -49,4 +50,4 @@ macro_rules! cpu_features {
         $result_vec.push(("rdseed", rdseed));
         $result_vec.push(("x2apic", x2));
     };
-}
+}

kernel/targets/aarch64-virt-ableos.json

@@ -1,25 +1,25 @@
 {
-	"arch": "aarch64",
-	"data-layout": "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128-Fn32",
-	"disable-redzone": true,
-	"env": "",
-	"executables": true,
-	"features": "+strict-align,+neon,+fp-armv8",
-	"linker": "rust-lld",
-	"linker-flavor": "ld.lld",
-	"linker-is-gnu": true,
-	"pre-link-args": {
-		"ld.lld": [
-			"-Tkernel/lds/aarch64-qemu.ld"
-		]
-	},
-	"llvm-target": "aarch64-unknown-none",
-	"max-atomic-width": 128,
-	"os": "none",
-	"panic-strategy": "abort",
-	"relocation-model": "static",
-	"target-c-int-width": "32",
-	"target-endian": "little",
-	"target-pointer-width": "64",
-	"vendor": "ablecorp"
+    "arch": "aarch64",
+    "data-layout": "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128",
+    "disable-redzone": true,
+    "env": "",
+    "executables": true,
+    "features": "+strict-align,+neon,+fp-armv8",
+    "linker": "rust-lld",
+    "linker-flavor": "ld.lld",
+    "linker-is-gnu": true,
+    "pre-link-args": {
+        "ld.lld": [
+            "-Tkernel/lds/aarch64-qemu.ld"
+        ]
+    },
+    "llvm-target": "aarch64-unknown-none",
+    "max-atomic-width": 128,
+    "os": "none",
+    "panic-strategy": "abort",
+    "relocation-model": "static",
+    "target-c-int-width": "32",
+    "target-endian": "little",
+    "target-pointer-width": "64",
+    "vendor": ""
 }

kernel/targets/x86_64-ableos.json

@@ -1,22 +1,22 @@
 {
-	"llvm-target": "x86_64-unknown-none",
-	"data-layout": "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128",
-	"arch": "x86_64",
-	"target-endian": "little",
-	"target-pointer-width": "64",
-	"target-c-int-width": "32",
-	"os": "none",
-	"executables": true,
-	"linker-flavor": "ld.lld",
-	"linker": "rust-lld",
-	"panic-strategy": "abort",
-	"disable-redzone": true,
-	"features": "",
-	"code-model": "kernel",
-	"pre-link-args": {
-		"ld.lld": [
-			"--gc-sections",
-			"--script=kernel/lds/x86_64.ld"
-		]
-	}
+    "llvm-target": "x86_64-unknown-none",
+    "data-layout": "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128",
+    "arch": "x86_64",
+    "target-endian": "little",
+    "target-pointer-width": "64",
+    "target-c-int-width": "32",
+    "os": "none",
+    "executables": true,
+    "linker-flavor": "ld.lld",
+    "linker": "rust-lld",
+    "panic-strategy": "abort",
+    "disable-redzone": true,
+    "features": "",
+    "code-model": "kernel",
+    "pre-link-args": {
+        "ld.lld": [
+            "--gc-sections",
+            "--script=kernel/lds/x86_64.ld"
+        ]
+    }
 }

kernel/targets/x86_64_v3-ableos.json

@@ -1,22 +0,0 @@
-{
-	"llvm-target": "x86_64-unknown-none",
-	"data-layout": "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128",
-	"arch": "x86_64",
-	"target-endian": "little",
-	"target-pointer-width": "64",
-	"target-c-int-width": "32",
-	"os": "none",
-	"executables": true,
-	"linker-flavor": "ld.lld",
-	"linker": "rust-lld",
-	"panic-strategy": "abort",
-	"disable-redzone": true,
-	"features": "+sse4.1,+avx,+aes,+fma,+popcnt,+bmi2,+avx2,+lzcnt,+xsave",
-	"code-model": "kernel",
-	"pre-link-args": {
-		"ld.lld": [
-			"--gc-sections",
-			"--script=kernel/lds/x86_64.ld"
-		]
-	}
-}

known_bugs.md

@@ -1,2 +0,0 @@
-# i did not know where to put this
-- memcpy / memset cause crash on debug builds due to ptr misalignment that is not present on release builds

repbuild/Cargo.toml

@@ -6,16 +6,24 @@ edition = "2021"
 [dependencies]
 str-reader = "0.1"
 derive_more = { version = "1", default-features = false, features = [
-	"display",
+  "add",
+  "add_assign",
+  "constructor",
+  "display",
+  "from",
+  "into",
+  "mul",
+  "mul_assign",
+  "not",
+  "sum",
 ] }
 error-stack = "0.5"
-fatfs = { version = "0.3", default-features = false, features = [
-	"std",
-	"alloc",
-] }
+fatfs = "0.3"
 toml = "0.8"
+# hbasm.git = "https://git.ablecorp.us/AbleOS/holey-bytes.git"
 hblang.git = "https://git.ablecorp.us/AbleOS/holey-bytes.git"
-# hblang.path = "../../holey-bytes/lang/"
-log = "0.4"
-raw-cpuid = "11"
-ureq = { version = "2", default-features = false, features = ["tls"] }
+
+[dependencies.reqwest]
+version = "0.12"
+default-features = false
+features = ["rustls-tls", "blocking"]

repbuild/src/dev.rs

@@ -1,6 +1,5 @@
 #![allow(unused)]
 use std::{
-    collections::HashMap,
     fmt::format,
     fs::{read_to_string, File},
     io::{BufWriter, Write},
@@ -14,7 +13,6 @@ pub struct Package {
     name:      String,
     binaries:  Vec<String>,
     build_cmd: String,
-    args:      HashMap<String, String>,
 }
 
 impl Package {
@@ -48,82 +46,57 @@ impl Package {
         let mut binaries = vec![];
 
         for (count, (name, table)) in bin_table.into_iter().enumerate() {
+            // if count != 0 {
+            println!("{}", name);
             binaries.push(name.clone());
+            // }
         }
         let build_table = data.get("build").unwrap();
 
         let mut build_cmd: String = build_table.get("command").unwrap().as_str().unwrap().into();
         build_cmd.remove(0);
-        let mut args: HashMap<String, String> = match build_table.get("args") {
-            None => HashMap::new(),
-            Some(v) => v
-                .as_table()
-                .unwrap()
-                .into_iter()
-                .map(|(k, v)| (k.clone(), v.to_string()))
-                .collect::<HashMap<String, String>>(),
-        };
+        // build_cmd.pop();
 
         Self {
             name,
             binaries,
             build_cmd,
-            args,
         }
     }
-    pub fn build(&self, out: &mut Vec<u8>) -> std::io::Result<()> {
+    pub fn build(&self) {
         if self.binaries.contains(&"hblang".to_string()) {
             let file = self.build_cmd.split_ascii_whitespace().last().unwrap();
+
             let path = format!("sysdata/programs/{}/{}", self.name, file);
+            let mut bytes = Vec::new();
             // compile here
 
-            let mut warnings = String::new();
-
-            hblang::run_compiler(
+            let _ = hblang::run_compiler(
                 &path,
                 Options {
                     fmt: true,
-                    resolver: Some(hblang::ABLEOS_PATH_RESOLVER),
-
                     ..Default::default()
                 },
-                out,
-                &mut warnings,
-            )?;
+                &mut bytes,
+            );
+            let _ = hblang::run_compiler(&path, Default::default(), &mut bytes);
 
             match std::fs::create_dir("target/programs") {
                 Ok(_) => (),
                 Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => (),
                 Err(e) => panic!("{}", e),
             }
-
-            hblang::run_compiler(
+            std::fs::write(format!("target/programs/{}.hbf", self.name), &bytes).unwrap();
+            bytes.clear();
+            let _ = hblang::run_compiler(
                 &path,
                 Options {
-                    resolver: Some(hblang::ABLEOS_PATH_RESOLVER),
-                    ..Default::default()
-                },
-                out,
-                &mut warnings,
-            )?;
-            std::fs::write(format!("target/programs/{}.hbf", self.name), &out)?;
-            out.clear();
-
-            let err = hblang::run_compiler(
-                &path,
-                Options {
-                    resolver: Some(hblang::ABLEOS_PATH_RESOLVER),
                     dump_asm: true,
-
                     ..Default::default()
                 },
-                out,
-                &mut warnings,
+                &mut bytes,
             );
-            std::fs::write(format!("target/programs/{}.hba", self.name), &out)?;
-            out.clear();
-            return err;
+            std::fs::write(format!("target/programs/{}.hba", self.name), &bytes).unwrap();
         }
-        Ok(())
     }
 }

repbuild/src/main.rs

@@ -1,16 +1,18 @@
+// #![allow(unused)]
+
 mod dev;
 
 use {
-    core::fmt::Write as _,
     derive_more::Display,
     dev::Package,
     error_stack::{bail, report, Context, Report, Result, ResultExt},
     fatfs::{FileSystem, FormatVolumeOptions, FsOptions, ReadWriteSeek},
     std::{
+        // fmt::Display,
         fs::{self, File},
         io::{self, Write},
         path::Path,
-        process::{exit, Command, Stdio},
+        process::{exit, Command},
     },
     toml::Value,
 };
@@ -19,15 +21,11 @@ fn main() -> Result<(), Error> {
     let mut args = std::env::args();
     args.next();
 
-    log::set_logger(&hblang::Logger).unwrap();
-    log::set_max_level(log::LevelFilter::Error);
-
     match args.next().as_deref() {
         Some("build" | "b") => {
             let mut release = false;
             let mut debuginfo = false;
             let mut target = Target::X86_64;
-            let mut tests = false;
             for arg in args {
                 if arg == "-r" || arg == "--release" {
                     release = true;
@@ -37,45 +35,17 @@ fn main() -> Result<(), Error> {
                     target = Target::Riscv64Virt;
                 } else if arg == "arm64" || arg == "aarch64" || arg == "aarch64-virt" {
                     target = Target::Aarch64;
-                } else if arg == "avx2" {
-                    target = Target::X86_64Avx2;
-                } else if arg == "--ktest" {
-                    tests = true;
                 } else {
                     return Err(report!(Error::InvalidSubCom));
                 }
             }
 
-            build(release, target, debuginfo, tests).change_context(Error::Build)
+            build(release, target, debuginfo).change_context(Error::Build)
         }
-        // Some("test" | "t") => {
-        //     let mut release = false;
-        //     let mut debuginfo = false;
-        //     let mut target = Target::X86_64;
-        //     for arg in args {
-        //         if arg == "-r" || arg == "--release" {
-        //             release = true;
-        //         } else if arg == "-d" || arg == "--debuginfo" {
-        //             debuginfo = true;
-        //         } else if arg == "rv64" || arg == "riscv64" || arg == "riscv64-virt" {
-        //             target = Target::Riscv64Virt;
-        //         } else if arg == "arm64" || arg == "aarch64" || arg == "aarch64-virt" {
-        //             target = Target::Aarch64;
-        //         } else if arg == "avx2" {
-        //             target = Target::X86_64Avx2;
-        //         } else {
-        //             return Err(report!(Error::InvalidSubCom));
-        //         }
-        //     }
-
-        //     test(release, target, debuginfo).change_context(Error::Build)
-        // }
         Some("run" | "r") => {
             let mut release = false;
             let mut debuginfo = false;
             let mut target = Target::X86_64;
-            let mut tests = false;
-            let mut do_accel = true;
             for arg in args {
                 if arg == "-r" || arg == "--release" {
                     release = true;
@@ -85,19 +55,13 @@ fn main() -> Result<(), Error> {
                     target = Target::Riscv64Virt;
                 } else if arg == "arm64" || arg == "aarch64" || arg == "aarch64-virt" {
                     target = Target::Aarch64;
-                } else if arg == "--noaccel" {
-                    do_accel = false;
-                } else if arg == "avx2" {
-                    target = Target::X86_64Avx2;
-                } else if arg == "--ktest" {
-                    tests = true;
                 } else {
                     return Err(report!(Error::InvalidSubCom));
                 }
             }
 
-            build(release, target, debuginfo, tests)?;
-            run(release, target, do_accel)
+            build(release, target, debuginfo)?;
+            run(release, target)
         }
         Some("help" | "h") => {
             println!(concat!(
@@ -107,11 +71,8 @@ fn main() -> Result<(), Error> {
                 "   help (h): Print this message\n",
                 "    run (r): Build and run AbleOS in QEMU\n\n",
                 "Options for build and run:\n",
-                "        -r / --release: build in release mode\n",
-                "        -d / --debuginfo: build with debug info\n",
-                "        --noaccel: run without acceleration (e.g, no kvm)\n",
-                "        --ktest: Enables tests via ktest\n",
-                "[ rv64 / riscv64 / riscv64-virt / aarch64 / arm64 / aarch64-virt / avx2 ]: sets target"
+                "        -r: build in release mode",
+                "  [target]: sets target"
             ),);
             Ok(())
         }
@@ -234,43 +195,21 @@ TERM_BACKDROP={}
         let modules = value.get_mut("modules").unwrap().as_table_mut().unwrap();
         // let mut real_modules = modules.clone();
 
-        let mut errors = String::new();
-        let mut out = Vec::new();
-
-        modules
-            .into_iter()
-            .map(|(_, value)| -> Result<(), io::Error> {
-                if value.is_table() {
-                    let path = get_path_without_boot_prefix(
-                        value.get("path").expect("You must have `path` as a value"),
-                    )
-                    .unwrap()
-                    .split(".")
-                    .next()
-                    .unwrap();
-                    let p = Package::load_from_file(
-                        format!("sysdata/programs/{}/meta.toml", path).to_owned(),
-                    );
-                    match p.build(&mut out) {
-                        Ok(()) => {}
-                        Err(e) => {
-                            writeln!(errors, "========= while compiling {} {} =========", path, e)
-                                .unwrap();
-                            errors.push_str(&String::from_utf8_lossy(&out));
-                            out.clear();
-                        }
-                    }
-                }
-                Ok(())
-            })
-            .for_each(drop);
-
-        if !errors.is_empty() {
-            let _ = writeln!(errors, "!!! STOPPING DUE TO PREVIOUS ERRORS !!!");
-            std::eprint!("{errors}");
-            continue;
-        }
-
+        modules.into_iter().for_each(|(_, value)| {
+            if value.is_table() {
+                let path = get_path_without_boot_prefix(
+                    value.get("path").expect("You must have `path` as a value"),
+                )
+                .unwrap()
+                .split(".")
+                .next()
+                .unwrap();
+                let p = Package::load_from_file(
+                    format!("sysdata/programs/{}/meta.toml", path).to_owned(),
+                );
+                p.build();
+            }
+        });
         modules.into_iter().for_each(|(_key, value)| {
             if value.is_table() {
                 let path = value.get("path").expect("You must have `path` as a value");
@@ -339,7 +278,7 @@ fn copy_file_to_img(fpath: &str, fs: &FileSystem<File>) {
     .expect("Copy failed");
 }
 
-fn build(release: bool, target: Target, debuginfo: bool, tests: bool) -> Result<(), Error> {
+fn build(release: bool, target: Target, debuginfo: bool) -> Result<(), Error> {
     let fs = get_fs().change_context(Error::Io)?;
     let mut com = Command::new("cargo");
     com.current_dir("kernel");
@@ -351,19 +290,12 @@ fn build(release: bool, target: Target, debuginfo: bool, tests: bool) -> Result<
         com.env("RUSTFLAGS", "-Cdebug-assertions=true");
     }
 
-    if tests {
-        com.args(["--features", "ktest"]);
-    }
-
     if target == Target::Riscv64Virt {
         com.args(["--target", "targets/riscv64-virt-ableos.json"]);
     }
     if target == Target::Aarch64 {
         com.args(["--target", "targets/aarch64-virt-ableos.json"]);
     }
-    if target == Target::X86_64Avx2 {
-        com.args(["--target", "targets/x86_64_v3-ableos.json"]);
-    }
 
     match com.status() {
         Ok(s) if s.code() != Some(0) => bail!(Error::Build),
@@ -377,10 +309,6 @@ fn build(release: bool, target: Target, debuginfo: bool, tests: bool) -> Result<
             path.push_str("_x86-64");
             "target/x86_64-ableos"
         }
-        Target::X86_64Avx2 => {
-            path.push_str("_x86-64");
-            "target/x86_64_v3-ableos"
-        }
         Target::Riscv64Virt => "target/riscv64-virt-ableos",
         Target::Aarch64 => {
             path.push_str("_aarch64");
@@ -403,73 +331,25 @@ fn build(release: bool, target: Target, debuginfo: bool, tests: bool) -> Result<
     .change_context(Error::Io)
 }
 
-fn run(release: bool, target: Target, do_accel: bool) -> Result<(), Error> {
-    let target_str = match target {
-        Target::X86_64 | Target::X86_64Avx2 => "qemu-system-x86_64",
-        Target::Riscv64Virt => "qemu-system-riscv64",
-        Target::Aarch64 => "qemu-system-aarch64",
+fn run(release: bool, target: Target) -> Result<(), Error> {
+    let mut com = match target {
+        Target::X86_64 => Command::new("qemu-system-x86_64"),
+        Target::Riscv64Virt => Command::new("qemu-system-riscv64"),
+        Target::Aarch64 => Command::new("qemu-system-aarch64"),
     };
-    let (mut com, mut com2) = (Command::new(target_str), Command::new(target_str));
     let ovmf_path = fetch_ovmf(target);
-    #[cfg(target_arch = "x86_64")]
-    let accel = if do_accel {
-        let supported = String::from_utf8(
-            com2.args(["--accel", "help"])
-                .stdout(Stdio::piped())
-                .stderr(Stdio::piped())
-                .spawn()
-                .unwrap()
-                .wait_with_output()
-                .unwrap()
-                .stdout,
-        )
-        .unwrap();
-
-        let cpuid = raw_cpuid::CpuId::new();
-        let vmx = cpuid.get_feature_info().unwrap().has_vmx();
-        let svm = cpuid.get_svm_info().is_some();
-
-        if supported.contains("kvm") && (vmx || svm) {
-            "accel=kvm"
-        } else if cpuid
-            .get_processor_brand_string()
-            .filter(|a| a.as_str() == "GenuineIntel")
-            .is_some()
-            && supported.contains("hax")
-            && vmx
-        {
-            "accel=hax"
-        } else if supported.contains("whpx") {
-            "accel=whpx"
-        } else {
-            "accel=tcg"
-        }
-    } else {
-        "accel=tcg"
-    };
-    #[cfg(not(target_arch = "x86_64"))]
-    let accel = "accel=tcg";
 
     match target {
-        Target::X86_64 | Target::X86_64Avx2 => {
+        Target::X86_64 => {
             #[rustfmt::skip]
             com.args([
                 "-bios", &ovmf_path.change_context(Error::OvmfFetch)?,
-                //"-hda", "target/disk.img",
-                "-drive", "file=target/disk.img,index=0,if=ide,format=raw",
-                "-device", "vmware-svga",
-                // "-serial", "stdio",
-                "-m", "2G",
-                "-smp", "1",
-																"-audiodev",
-																"pa,id=speaker",
-																"-machine",
-																"pcspk-audiodev=speaker",
-                "-parallel", "none",
-                "-monitor", "none",
-                "-machine", accel,
-                "-cpu", "max",
-                "-device", "isa-debug-exit,iobase=0xf4,iosize=0x04",
+                "-drive", "file=target/disk.img,format=raw",
+                "-m", "4G",
+                "-smp", "cores=4",
+                "-enable-kvm",
+                "-cpu", "host",
+                "-device", "isa-debug-exit,iobase=0xf4,iosize=0x04"
             ]);
         }
         Target::Riscv64Virt => {
@@ -490,7 +370,7 @@ fn run(release: bool, target: Target, do_accel: bool) -> Result<(), Error> {
             #[rustfmt::skip]
             com.args([
                 "-M", "virt",
-                "-cpu", "max",
+                "-cpu", "neoverse-n2",
                 "-device", "ramfb",
                 "-device", "qemu-xhci",
                 "-device", "usb-kbd",
@@ -513,7 +393,7 @@ fn run(release: bool, target: Target, do_accel: bool) -> Result<(), Error> {
 
 fn fetch_ovmf(target: Target) -> Result<String, OvmfFetchError> {
     let (ovmf_url, ovmf_path) = match target {
-        Target::X86_64 | Target::X86_64Avx2 => (
+        Target::X86_64 => (
             "https://retrage.github.io/edk2-nightly/bin/RELEASEX64_OVMF.fd",
             "target/RELEASEX64_OVMF.fd",
         ),
@@ -535,12 +415,12 @@ fn fetch_ovmf(target: Target) -> Result<String, OvmfFetchError> {
         Ok(_) => return Ok(ovmf_path.to_owned()),
         Err(e) => return Err(report!(e).change_context(OvmfFetchError::Io)),
     };
-    let req = ureq::get(ovmf_url)
-        .call()
+    let mut bytes = reqwest::blocking::get(ovmf_url)
         .map_err(Report::from)
         .change_context(OvmfFetchError::Fetch)?;
 
-    std::io::copy(&mut req.into_reader(), &mut file)
+    bytes
+        .copy_to(&mut file)
         .map_err(Report::from)
         .change_context(OvmfFetchError::Io)?;
 
@@ -562,7 +442,6 @@ impl Context for OvmfFetchError {}
 #[derive(Clone, Copy, PartialEq, Eq)]
 enum Target {
     X86_64,
-    X86_64Avx2,
     Riscv64Virt,
     Aarch64,
 }

rust-toolchain.toml

@@ -1,7 +1,3 @@
 [toolchain]
-# old toolchain
-# channel = "nightly-2024-07-27"
-# last stable
-# channel = "nightly-2024-11-20"
-channel = "nightly"
+channel = "nightly-2024-07-27"
 components = ["rust-src", "llvm-tools"]

sysdata/assets/consolefonts/tamsyn/LICENSE

@@ -1,10 +0,0 @@
-Tamsyn font is free.  You are hereby granted permission to use, copy, modify,
-and distribute it as you see fit.
-
-Tamsyn font is provided "as is" without any express or implied warranty.
-
-The author makes no representations about the suitability of this font for
-a particular purpose.
-
-In no event will the author be held liable for damages arising from the use
-of this font.

sysdata/idl/abc/src/protocol.aidl

@@ -0,0 +1,2 @@
+protocol abc {
+                }

sysdata/idl/log/src/protocol.aidl

@@ -1,24 +0,0 @@
-@auto_increment
-enum LogLevel {
-    Error = 0,
-    Warn,
-    Info,
-    Debug,
-    Trace,
-}
-
-@auto_increment
-enum LogResult {
-    Err = 0,
-    Ok,
-}
-
-struct Log {
-    log_level: LogLevel,
-}
-
-@visibility(public)
-protocol Log {
-    fn log(Log) -> LogResult;
-    fn flush() -> LogResult;
-}

sysdata/libraries/horizon_api/examples/horizontal.lui

@@ -1,4 +0,0 @@
-(horizontal
-    spacing : 10
-    (label "hi")
-    (label "goodbye"))

sysdata/libraries/horizon_api/examples/label.lui

@@ -1 +0,0 @@
-(label "hello")

sysdata/libraries/horizon_api/examples/vertical.lui

@@ -1,3 +0,0 @@
-(vertical
-    (label "hello")
-    (label "hello" color:red))

sysdata/libraries/horizon_api/src/element.hb

@@ -0,0 +1,14 @@
+Element := struct {
+    width: int,
+    height: int, 
+
+    x: u16,
+    y: u16,
+
+    id: int,
+}
+
+create_element := fn(): Element {
+    return Element.(0, 0, 0, 0, 0)
+}
+

sysdata/libraries/horizon_api/src/frame.hb

@@ -0,0 +1,3 @@
+FrameID := struct {
+
+}

sysdata/libraries/horizon_api/src/lib.hb

@@ -1,43 +1,12 @@
-stn := @use("../../stn/src/lib.hb");
-.{string, memory, buffer, log} := stn
-
-render := @use("../../../libraries/render/src/lib.hb")
-
-input := @use("../../intouch/src/lib.hb")
-
-widgets := @use("widgets/widgets.hb")
-ui := @use("ui.hb")
-
 WindowID := struct {
 	host_id: int,
 	window_id: int,
 }
 
-VoidWindowID := WindowID.(0, 0)
-
-create_window := fn(channel: int): ^render.Surface {
-	// get the horizon buffer
-	// request a new window and provide the callback buffer
-	// wait to recieve a message
-
-	windowing_system_buffer := buffer.search("XHorizon\0")
-	mem_buf := memory.request_page(1)
-
-	if windowing_system_buffer == 0 {
-		return @as(^render.Surface, idk)
-	} else {
-		x := 0
-		loop if x > 1000 break else x += 1
-
-		ret := buffer.recv([4096]u8, windowing_system_buffer, mem_buf)
-		if ret == null {
-			log.info("No messages\0")
-		}
-
-		if *mem_buf == 0 {
-			log.info("No messages\0")
-		}
-
-		return @as(^render.Surface, idk)
-	}
+create_window := fn(): WindowID {
+	return WindowID.(1, 2)
 }
+
+update_ui := fn(window_id: WindowID): void {
+	return
+}

sysdata/libraries/horizon_api/src/text.hb

@@ -0,0 +1,3 @@
+ui_lisp_text_example := "(text id_1)\0";
+
+

sysdata/libraries/horizon_api/src/ui.hb

@@ -1,47 +0,0 @@
-stn := @use("../../../libraries/stn/src/lib.hb");
-.{string, log} := stn;
-.{Vec2} := stn.math
-
-render := @use("../../../libraries/render/src/lib.hb");
-.{Surface} := render;
-.{Font} := render.text
-
-UI := struct {raw: ^u8, raw_length: uint, is_dirty: bool, surface: Surface, // Each child has their WidgetType as their first byte
-// children: ^^u8,
-}
-
-render_ui := fn(surface: Surface, ui: UI): void {
-	if ui.is_dirty {
-		render.clear(ui.surface, render.black)
-		ui.is_dirty = false
-	}
-	pos := Vec2(uint).(0, 0)
-	render.put_surface(surface, ui.surface, pos, false)
-}
-
-sexpr_parser := fn(sexpr: ^u8): UI {
-	cursor := sexpr
-	paren_balance := 0
-	loop {
-		if *cursor == 0 {
-			if paren_balance != 0 {
-				log.error("Unbalanced Parens\0")
-			}
-			break
-		} else if *cursor == 40 {
-			log.info("Open paren\0")
-			paren_balance += 1
-		} else if *cursor == 41 {
-			log.info("Closed paren\0")
-			paren_balance -= 1
-		}
-
-		cursor += 1
-	}
-
-	length := string.length(sexpr)
-
-	ui_surface := render.new_surface(100, 100)
-
-	return UI.(sexpr, length, true, ui_surface)
-}

sysdata/libraries/horizon_api/src/widgets/image.hb

@@ -1,13 +0,0 @@
-render := @use("../../../../libraries/render/src/lib.hb");
-.{Surface} := render
-
-Image := struct {
-	magic: uint,
-	is_dirty: bool,
-	surface: Surface,
-}
-
-image_from_surface := fn(surface: Surface): Image {
-	img := Image.(4, true, surface)
-	return img
-}

sysdata/libraries/horizon_api/src/widgets/label.hb

@@ -1,46 +0,0 @@
-stn := @use("../../../../libraries/stn/src/lib.hb");
-.{string, log} := stn;
-.{Vec2} := stn.math
-
-render := @use("../../../../libraries/render/src/lib.hb");
-.{Surface, Color} := render;
-.{Font} := render.text
-
-Label := struct {
-	magic: uint,
-	is_dirty: bool,
-	surface: Surface,
-	text: ^u8,
-	text_length: uint,
-	bg: Color,
-	fg: Color,
-
-	new_label := fn(text: ^u8, width: uint): Self {
-		text_surface := render.Surface.new(width, 20)
-		text_length := string.length(text)
-		label := Self.(3, true, text_surface, text, text_length, render.BLACK, render.WHITE)
-		return label
-	}
-
-	set_label_text := fn(self: Self, text: ^u8): void {
-		text_length := string.length(text)
-
-		self.is_dirty = true
-		self.text = text
-		self.text_length = text_length
-	}
-
-	$set_color := fn(self: Self, bg: Color, fg: Color): void {
-		self.bg = bg
-		self.fg = fg
-		self.is_dirty = true
-	}
-}
-
-render_label_to_surface := fn(surface: Surface, label: Label, font: Font, pos: Vec2(uint)): void {
-	if label.is_dirty {
-		label.surface.clear(label.bg)
-		label.surface.put_text(font, .(0, 0), label.fg, label.text)
-	}
-	surface.put_surface(label.surface, pos, false)
-}

sysdata/libraries/horizon_api/src/widgets/widget_types.hb

@@ -1,7 +0,0 @@
-NoWidget := 0
-
-VerticalWidgetType := 1
-HorizontalWidgetType := 2
-
-LabelWidgetType := 3
-ImageWidgetType := 4

sysdata/libraries/horizon_api/src/widgets/widgets.hb

@@ -1,36 +0,0 @@
-// Widget types
-
-// End types
-stn := @use("../../../../libraries/stn/src/lib.hb");
-.{string, log} := stn;
-.{Vec2} := stn.math
-
-render := @use("../../../../libraries/render/src/lib.hb");
-.{Surface} := render;
-.{Font} := render.text
-
-widget_types := @use("widget_types.hb")
-label := @use("label.hb")
-image := @use("image.hb")
-
-Size := struct {
-	min_width: int,
-	max_width: int,
-	min_height: int,
-	max_height: int,
-}
-
-Vertical := packed struct {
-	magic: uint,
-	// array of children, idk
-	// use a vec or linked list or whatever
-
-	children: ^^u8,
-}
-
-Horizontal := packed struct {
-	magic: uint,
-	// array of children, idk
-	// use a vec or linked list or whatever
-	children: ^^u8,
-}

sysdata/libraries/ignim/src/application.hb

@@ -1,21 +0,0 @@
-structures := @use("structures.hb")
-version := @use("version.hb")
-
-// Refer to here https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VkApplicationInfo.html
-ApplicationInfo := struct {
-	sType: int,
-	pNext: ^int,
-	application_name: ^u8,
-	application_version: int,
-	engine_name: ^u8,
-	engine_version: int,
-	api_version: int,
-}
-
-new_application_info := fn(app_name: ^u8, app_version: int, engine_name: ^u8, engine_version: int, api_version: int): ApplicationInfo {
-	app_info_type := structures.ApplicationInfoType
-
-	app_info := ApplicationInfo.(app_info_type, 0, app_name, app_version, engine_name, engine_version, api_version)
-
-	return app_info
-}

sysdata/libraries/ignim/src/errors.hb

@@ -1,14 +0,0 @@
-OutOfHostMemory := -1
-OutOfDeviceMemory := -2
-InitializationFailed := -3
-DeviceLost := -4
-MemoryMapFailed := -5
-
-LayerNotPresent := -6
-ExtensionNotPresent := -7
-FeatureNotPresent := -8
-IncompatibleDriver := -9
-TooManyObjects := -10
-FormatNotSupported := -11
-FragmentedPool := -12
-Unknown := -13

sysdata/libraries/ignim/src/extends.hb

@@ -1,10 +0,0 @@
-Extent3D := struct {
-	width: int,
-	height: int,
-	depth: int,
-}
-
-Extent2D := struct {
-	width: int,
-	height: int,
-}

sysdata/libraries/ignim/src/instance.hb

@@ -1,35 +0,0 @@
-application := @use("application.hb");
-.{ApplicationInfo} := application
-
-structures := @use("structures.hb")
-errors := @use("errors.hb")
-
-// https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VkInstanceCreateInfo.html
-InstanceCreateInfo := struct {
-	sType: int,
-	pNext: int,
-	flags: int,
-	application_info: ^ApplicationInfo,
-	enabled_layer_count: int,
-	ppEnabledLayerNames: int,
-	enabled_extension_count: int,
-	ppEnabledExtensionNames: int,
-}
-
-new_create_info := fn(application_info: ^ApplicationInfo): InstanceCreateInfo {
-	create_info_type := structures.InstanceCreateInfoType
-	enabled_layer_count := 0
-
-	create_info := InstanceCreateInfo.(create_info_type, 0, 0, application_info, enabled_layer_count, 0, 0, 0)
-	return create_info
-}
-
-// TODO
-Instance := struct {inner: int}
-void_instance := fn(): Instance {
-	return Instance.(0)
-}
-
-create_instance := fn(create_info: ^InstanceCreateInfo, allocator_callback: int, new_obj: ^Instance): int {
-	return errors.IncompatibleDriver
-}

sysdata/libraries/ignim/src/lib.hb

@@ -1,17 +1,7 @@
-application := @use("application.hb")
+VK_VERSION_MAJOR := 1;
+VK_VERSION_MINOR := 0;
 
-results := @use("results.hb")
-errors := @use("errors.hb")
-
-offsets := @use("offset.hb")
-extends := @use("extends.hb")
-
-rect := @use("rect.hb")
-structures := @use("structures.hb")
-instance := @use("instance.hb")
-
-version := @use("version.hb")
-
-init_vulkan := fn(): int {
-	return errors.IncompatibleDriver
+init_vulkan := fn(): void {
+    
+    return
 }

sysdata/libraries/ignim/src/offset.hb

@@ -1,10 +0,0 @@
-Offset3D := struct {
-	x: int,
-	y: int,
-	z: int,
-}
-
-Offset2D := struct {
-	x: int,
-	y: int,
-}

sysdata/libraries/ignim/src/rect.hb

@@ -1,7 +0,0 @@
-offsets := @use("offset.hb")
-extends := @use("extends.hb")
-
-Rect2D := struct {
-	offset: offsets.Offset2D,
-	extent: extends.Extent2D,
-}

sysdata/libraries/ignim/src/results.hb

@@ -1,7 +0,0 @@
-// NonErrors
-Success := 0
-NotReady := 1
-Timeout := 2
-EventSet := 3
-EventReset := 4
-Incomplete := 5

sysdata/libraries/ignim/src/structures.hb

@@ -1,61 +0,0 @@
-ApplicationInfoType := 0
-InstanceCreateInfoType := 1
-DeviceQueueCreateInfo := 2
-DeviceCreateInfo := 3
-SubmitInfo := 4
-MemoryAllocateInfo := 5
-MappedMemoryRange := 6
-BindSparseInfo := 7
-
-FenceCreateInfo := 8
-SemaphoreCreateInfo := 9
-EventCreateInfo := 10
-QueryPoolCreateInfo := 11
-
-BufferCreateInfo := 12
-BufferViewCreateInfo := 13
-
-ImageCreateInfo := 14
-ImageViewCreateInfo := 15
-
-ShaderModuleCreateInfo := 16
-
-PipelineCacheCreateInfo := 17
-PipelineShaderStageCreateInfo := 18
-PipelineVertexInputStateCreateInfo := 19
-PipelineInputAssemblyStateCreateInfo := 20
-PipelineTessellationStateCreateInfo := 21
-PipelineViewportStateCreateInfo := 22
-PipelineRasterizationStateCreateInfo := 23
-PipelineMultisampleStateCreateInfo := 24
-PipelineDepthStencilStateCreateInfo := 25
-PipelineColorBlendStateCreateInfo := 26
-PipelineDynamicStateCreateInfo := 27
-
-GraphicsPipelineCreateInfo := 28
-ComputePipelineCreateInfo := 29
-PipelineLayoutCreateInfo := 30
-SamplerCreateInfo := 31
-
-DescriptorSetLayoutCreateInfo := 32
-DescriptorPoolCreateInfo := 33
-
-DescriptorSetAllocateInfo := 34
-WriteDescriptorSet := 35
-CopyDescriptorSet := 36
-FramebufferCreateInfo := 37
-
-RenderPassCreateInfo := 38
-CommandPoolCreateInfo := 39
-
-CommandBufferAllocateInfo := 40
-CommandBufferInheritanceInfo := 41
-CommandBufferBeginInfo := 42
-
-RenderPassBeginInfo := 43
-BufferMemoryBarrier := 44
-ImageMemoryBarrier := 45
-MemoryBarrier := 46
-
-LoaderInstanceCreateInfo := 47
-LoaderDeviceCreateInfo := 48

sysdata/libraries/ignim/src/version.hb

@@ -1,9 +0,0 @@
-ApiVersion1_0 := make_api_version(0, 1, 0, 0)
-
-make_version := fn(major: int, minor: int, patch: int): int {
-	return major << 22 | minor << 12 | patch
-}
-
-make_api_version := fn(variant: int, major: int, minor: int, patch: int): int {
-	return variant << 29 | major << 22 | minor << 12 | patch
-}

sysdata/libraries/intouch/README.md

@@ -1,20 +0,0 @@
-# intouch
-This library is exclusively focused on allowing your to get input regardless of which devices you have.
-
-Partially modeled after SDL.
-
-Current goals include
-- Interfaces
-    - PS/2
-- Device Types
-    - Keyboard
-    - Mouse
-
-Longer Term goals 
-- Interfaces
-    - USB
-    - USB-HID
-- Device Types
-    - Gamepads/controllers
-    - Drawing Tablets
-    - Microphones

sysdata/libraries/intouch/key_maps/ps2.map

@@ -1,2 +0,0 @@
-0x0D -> press Tab
-0xF0 0x0D -> release Tab

sysdata/libraries/intouch/src/events.hb

@@ -1,18 +0,0 @@
-keycodes := @use("keycodes.hb");
-.{KeyCode} := keycodes
-
-KeyEvent := packed struct {
-	up: bool,
-	just_triggered: bool,
-	key: KeyCode,
-}
-
-MouseEvent := packed struct {
-	x_change: i8,
-	y_change: i8,
-	left: bool,
-	middle: bool,
-	right: bool,
-}
-
-GamepadEvent := struct {}

sysdata/libraries/intouch/src/keycodes.hb

@@ -1,121 +0,0 @@
-/*
-Originally I was modelling this after the following(1). I have since changed my mind.
-I am now modelling it as I see fit. This is likely not the final version.
-
-1) https://www.libsdl.org/release/SDL-1.2.15/include/SDL_keysym.h
-*/
-
-KeyCode := u32
-
-// Typically this is not a keycode you will ever recieve.
-None := KeyCode.(0)
-
-Escape := KeyCode.(1)
-/* Alphabet keycodes */
-
-A := KeyCode.(2)
-B := KeyCode.(3)
-C := KeyCode.(4)
-D := KeyCode.(5)
-E := KeyCode.(6)
-F := KeyCode.(7)
-G := KeyCode.(8)
-H := KeyCode.(9)
-I := KeyCode.(10)
-J := KeyCode.(11)
-K := KeyCode.(12)
-L := KeyCode.(13)
-M := KeyCode.(14)
-N := KeyCode.(15)
-O := KeyCode.(16)
-P := KeyCode.(17)
-Q := KeyCode.(18)
-R := KeyCode.(19)
-S := KeyCode.(20)
-T := KeyCode.(21)
-U := KeyCode.(22)
-V := KeyCode.(23)
-W := KeyCode.(24)
-X := KeyCode.(25)
-Y := KeyCode.(26)
-Z := KeyCode.(27)
-
-/* Numeric keycodes*/
-
-Number0 := KeyCode.(28)
-Number1 := KeyCode.(29)
-Number2 := KeyCode.(30)
-Number3 := KeyCode.(31)
-Number4 := KeyCode.(32)
-Number5 := KeyCode.(33)
-Number6 := KeyCode.(34)
-Number7 := KeyCode.(35)
-Number8 := KeyCode.(36)
-Number9 := KeyCode.(37)
-
-KeypadNumber0 := KeyCode.(38)
-KeypadNumber1 := KeyCode.(39)
-KeypadNumber2 := KeyCode.(40)
-KeypadNumber3 := KeyCode.(41)
-KeypadNumber4 := KeyCode.(42)
-KeypadNumber5 := KeyCode.(43)
-KeypadNumber6 := KeyCode.(44)
-KeypadNumber7 := KeyCode.(45)
-KeypadNumber8 := KeyCode.(46)
-KeypadNumber9 := KeyCode.(47)
-
-KeypadPeriod := KeyCode.(48)
-KeypadDivide := KeyCode.(49)
-KeypadMultiply := KeyCode.(50)
-KeypadMinus := KeyCode.(51)
-KeypadPlus := KeyCode.(52)
-KeypadEnter := KeyCode.(53)
-KeypadEquals := KeyCode.(54)
-
-Delete := KeyCode.(55)
-/* Locking Keys */
-NumLock := KeyCode.(56)
-CapsLock := KeyCode.(57)
-ScrollLock := KeyCode.(58)
-
-/* "Alt Gr" key */
-Mode := KeyCode.(59)
-
-/* Multi-key compose key */
-Compose := KeyCode.(60)
-
-LeftAlt := KeyCode.(61)
-LeftControl := KeyCode.(62)
-LeftMeta := KeyCode.(63)
-LeftShift := KeyCode.(64)
-/* Left "Windows" key */
-LeftSuper := KeyCode.(65)
-
-RightAlt := KeyCode.(66)
-RightControl := KeyCode.(67)
-RightMeta := KeyCode.(68)
-RightShift := KeyCode.(69)
-/* Right "Windows" key */
-RightSuper := KeyCode.(70)
-
-/*
-    This block of any triggers on any press of any of the keys.
-    Typically this is the event to care about.
-*/
-AnyNumber0 := KeyCode.(71)
-AnyNumber1 := KeyCode.(72)
-AnyNumber2 := KeyCode.(73)
-AnyNumber3 := KeyCode.(74)
-AnyNumber4 := KeyCode.(75)
-AnyNumber5 := KeyCode.(76)
-AnyNumber6 := KeyCode.(77)
-AnyNumber7 := KeyCode.(78)
-AnyNumber8 := KeyCode.(79)
-AnyNumber9 := KeyCode.(80)
-
-AnyAlt := KeyCode.(81)
-AnyControl := KeyCode.(82)
-AnyMeta := KeyCode.(83)
-AnyShift := KeyCode.(84)
-/* Any "Windows" key */
-AnySuper := KeyCode.(85)