adding a deadlock to master :>

Cargo.lock

@@ -29,9 +29,9 @@ dependencies = [
  "ab_glyph",
  "acpi",
  "axel",
+ "bitflags",
  "bootloader",
  "cpuio",
- "embedded-graphics",
  "ext2",
  "externc-libm",
  "facepalm",
@@ -134,7 +134,7 @@ checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
 [[package]]
 name = "axel"
 version = "0.1.0"
-source = "git+https://git.ablecorp.us/able/aos_userland#a9721a7b034ec24c3bc2b6ffe6fa989b47b144ef"
+source = "git+https://git.ablecorp.us/able/aos_userland#7f61266a9b6a5d0032ff84b3ee971eb7b14bd1fa"
 dependencies = [
  "hashbrown 0.7.2",
  "log",
@@ -142,12 +142,6 @@ dependencies = [
  "versioning",
 ]
 
-[[package]]
-name = "az"
-version = "1.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f771a5d1f5503f7f4279a30f3643d3421ba149848b89ecaaec0ea2acf04a5ac4"
-
 [[package]]
 name = "bare-metal"
 version = "1.0.0"
@@ -178,12 +172,6 @@ version = "0.9.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "de78decc37247c7cfac5dbf3495c7298c6ac97cb355161caa7e15969c6648e6c"
 
-[[package]]
-name = "byteorder"
-version = "1.4.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
-
 [[package]]
 name = "cfg-if"
 version = "1.0.0"
@@ -283,29 +271,6 @@ version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9ea835d29036a4087793836fa931b08837ad5e957da9e23886b29586fb9b6650"
 
-[[package]]
-name = "embedded-graphics"
-version = "0.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "750082c65094fbcc4baf9ba31583ce9a8bb7f52cadfb96f6164b1bc7f922f32b"
-dependencies = [
- "az",
- "byteorder",
- "embedded-graphics-core",
- "float-cmp",
- "micromath",
-]
-
-[[package]]
-name = "embedded-graphics-core"
-version = "0.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b8b1239db5f3eeb7e33e35bd10bd014e7b2537b17e071f726a09351431337cfa"
-dependencies = [
- "az",
- "byteorder",
-]
-
 [[package]]
 name = "ext2"
 version = "0.1.1"
@@ -331,15 +296,6 @@ dependencies = [
  "log",
 ]
 
-[[package]]
-name = "float-cmp"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e1267f4ac4f343772758f7b1bdcbe767c218bbab93bb432acbf5162bbf85a6c4"
-dependencies = [
- "num-traits",
-]
-
 [[package]]
 name = "fnv"
 version = "1.0.7"
@@ -490,9 +446,9 @@ dependencies = [
 
 [[package]]
 name = "log"
-version = "0.4.16"
+version = "0.4.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6389c490849ff5bc16be905ae24bc913a9c8892e19b2341dbc175e14c341c2b8"
+checksum = "abb12e687cfb44aa40f41fc3978ef76448f9b6038cad6aef4259d3c095a2382e"
 dependencies = [
  "cfg-if",
 ]
@@ -533,12 +489,6 @@ version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "71d96e3f3c0b6325d8ccd83c33b28acb183edcb6c67938ba104ec546854b0882"
 
-[[package]]
-name = "micromath"
-version = "1.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bc4010833aea396656c2f91ee704d51a6f1329ec2ab56ffd00bfd56f7481ea94"
-
 [[package]]
 name = "no-std-compat"
 version = "0.4.1"
@@ -1029,7 +979,7 @@ checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
 [[package]]
 name = "versioning"
 version = "0.1.2"
-source = "git+https://git.ablecorp.us/able/aos_userland#a9721a7b034ec24c3bc2b6ffe6fa989b47b144ef"
+source = "git+https://git.ablecorp.us/able/aos_userland#7f61266a9b6a5d0032ff84b3ee971eb7b14bd1fa"
 dependencies = [
  "serde",
 ]

ableos/Cargo.toml

@@ -46,14 +46,13 @@ test-args = [
 ]
 
 [dependencies]
-lazy_static = { version = "*", features = ["spin_no_std"] }
+lazy_static = { version = "1.4.0", features = ["spin_no_std"] }
 qrcode = { path = "../qrcode-rust" }
-
+bitflags = "1.2.1"
-
 linked_list_allocator = "0.9.0"
 lliw = "0.2.0"
 spin = "0.9"
-log = "*"
+log = "0.4.17"
 pretty-hex = "0.2.1"
 unicode-width = "0.1.7"
 picorand = "0.1.0"
@@ -63,8 +62,9 @@ rhai = "1.6.0"
 libwasm = { git = "https://git.ablecorp.us:443/able/libwasm.git" }
 axel = { git = "https://git.ablecorp.us/able/aos_userland" }
 versioning = { git = "https://git.ablecorp.us/able/aos_userland" }
-embedded-graphics = "*"
+# embedded-graphics = "*"
 pc-keyboard = "0.5"
+
 [dependencies.logos]
 version = "0.12"
 default-features = false
@@ -138,7 +138,7 @@ cpuio = { git = "https://git.ablecorp.us/ondra05/cpuio.git" }
 pic8259 = "0.10.1"
 uart_16550 = "0.2.0"
 volatile = "0.2.6"
-x86_64 = "*"
+x86_64 = "0.14.8"
 pc-beeper = { git = "https://github.com/AbleOS/pc-beeper" }
-vga = "*"
+vga = "0.2.7"
 acpi = "4.1.0"

ableos/src/arch/x86_64/drivers/mod.rs

@@ -1,5 +1,5 @@
 pub mod allocator;
-pub mod graphics;
+// pub mod graphics;
 pub mod serial;
 pub mod sysinfo;
 pub mod timer;

ableos/src/arch/x86_64/init.rs

@@ -1,22 +1,24 @@
 // #![allow(clippy::print_literal)]
-use super::{gdt, interrupts};
+use super::{drivers::serial, gdt, interrupts};
 use crate::{logger, serial_println};
 
 /// x86_64 initialization
 pub fn init() {
-    use crate::{network::socket::SimpleSock, relib::network::socket::Socket};
+    // use crate::{network::socket::SimpleSock, relib::network::socket::Socket};
 
-    let mut log_socket_id = SimpleSock::new();
+    // let mut log_socket_id = SimpleSock::new();
-    log_socket_id.register_protocol("Logger".to_string());
+    // log_socket_id.register_protocol("Logger".to_string());
 
     let result = logger::init();
     match result {
         Ok(_) => {
-            serial_println!("Logger initialized");
+            info!("Logger initialized");
         }
-        Err(err) => error!("{}", err),
+        Err(err) => serial_println!("{}", err),
     }
 
+    /*
+     */
     gdt::init();
 
     interrupts::init_idt();

ableos/src/arch/x86_64/interrupts.rs

@@ -18,6 +18,8 @@ use spin::Lazy;
 use vga::colors::Color16;
 use x86_64::structures::idt::{InterruptDescriptorTable, InterruptStackFrame};
 
+use super::sloop;
+
 pub const PIC_1_OFFSET: u8 = 32;
 pub const PIC_2_OFFSET: u8 = PIC_1_OFFSET + 8;
 
@@ -30,6 +32,9 @@ pub static PICS: spin::Mutex<ChainedPics> =
 pub enum InterruptIndex {
     Timer = PIC_1_OFFSET,
     Keyboard,
+    /// Mouse offset
+    Mouse = 44,
+
     // SecondInterrupt = PIC_2_OFFSET,
     Cmos = 0x70,
 }
@@ -56,11 +61,11 @@ static IDT: Lazy<InterruptDescriptorTable> = Lazy::new(|| {
 
     idt[InterruptIndex::Timer.as_usize()].set_handler_fn(timer_interrupt_handler);
     idt[InterruptIndex::Keyboard.as_usize()].set_handler_fn(keyboard_interrupt_handler);
-
+    idt[InterruptIndex::Mouse.as_usize()].set_handler_fn(crate::hardware::mouse_interrupt_handler);
-    idt[6].set_handler_fn(floppy_disk_interrupt_handler);
 
     // run `a + b + l + e + o + s print;` in ablescript and its 54 thats why this seemingly arbitrary number was chosen
     idt[54].set_handler_fn(software_int_handler);
+
     idt
 });
 
@@ -78,7 +83,7 @@ extern "x86-interrupt" fn double_fault_handler(
     _error_code: u64,
 ) -> ! {
     bsod(BSODSource::DoubleFault(&stack_frame));
-    // panic!("EXCEPTION: DOUBLE FAULT\n{:#?}", stack_frame);
+    panic!("EXCEPTION: DOUBLE FAULT\n{:#?}", stack_frame);
 }
 
 #[naked]
@@ -87,6 +92,7 @@ extern "x86-interrupt" fn timer_interrupt_handler(_stack_frame: InterruptStackFr
     unsafe {
         // print!(".");
         asm!(
+
             // Kernel tick
             "call {tick}",
 
@@ -99,7 +105,7 @@ extern "x86-interrupt" fn timer_interrupt_handler(_stack_frame: InterruptStackFr
             // Switch to next task (interrupt'll be returned there)
             "jmp {switch_to_next}",
 
-            tick = sym kernel::tick,
+            tick = sym crate::kmain::tick,
             save = sym task_switcher::save_and_enqueue,
             switch_to_next = sym task_switcher::switch_to_next,
             options(noreturn),
@@ -122,14 +128,16 @@ extern "x86-interrupt" fn keyboard_interrupt_handler(_stack_frame: InterruptStac
         .add_byte(unsafe { Port::new(0x60).read() })
         .map(|x| x.and_then(|ev| keyboard.process_keyevent(ev)))
     {
+        trace!("{key:?}");
         match key {
             DecodedKey::Unicode(chr) => match chr {
                 // Backspace
                 '\u{8}' => {
+                    // TODO: Fix this and apply to new term
                     WRITER.lock().backspace();
                     KEYBUFF.lock().push(8.into());
                 }
-                '^' => KERNEL_STATE.lock().shutdown(),
+                // '^' => KERNEL_STATE.lock().shutdown(),
                 chr => {
                     KEYBUFF.lock().push(chr);
                     print!("{chr}");
@@ -155,10 +163,6 @@ extern "x86-interrupt" fn keyboard_interrupt_handler(_stack_frame: InterruptStac
     }
 }
 
-extern "x86-interrupt" fn floppy_disk_interrupt_handler(_stack_frame: InterruptStackFrame) {
-    println!("EXCEPTION: FLOPPY DISK");
-}
-
 pub fn init_idt() {
     IDT.load();
 }
@@ -200,6 +204,8 @@ pub fn reset_pit_for_cpu() {
     set_pit_3(1000);
 }
 pub fn bsod(src: BSODSource) -> ! {
+    trace!("{src:?}");
+
     let mut mode = SCREEN_BUFFER.lock();
     mode.force_redraw();
     /*
@@ -214,17 +220,20 @@ pub fn bsod(src: BSODSource) -> ! {
     let mut y = 0;
 
     let src1 = match src {
-        BSODSource::DoubleFault(_) => "DoubleFault",
+        BSODSource::DoubleFault(_) => "DoubleFault".to_string(),
-        BSODSource::Panic(_) => "Panic",
+        BSODSource::Panic(panic_info) => {
+            let strr = format!("PANIC: {}", panic_info);
+            strr
+        }
     };
 
     let st = format!(
-        "We fucked up ඞ : {}\nThe following qr code will link you to the\nwiki which hopefully solves your problems",
+        "We fucked up ඞ : \n{}\nThe following qr code will link you to the wiki which hopefully solves your problems",
         src1
     );
 
     for current in st.chars() {
-        if current == '\n' {
+        if current == '\n' || x == 40 {
             y += 1;
             x = 1;
         } else {
@@ -239,16 +248,15 @@ pub fn bsod(src: BSODSource) -> ! {
     }
 
     let mut x = 1;
-    let mut y = 11;
+    let mut y = 34;
 
     // let sf = format!("https://git.ablecorp.us/able/ableos/wiki/Double-Faults");
 
     let sd = match src {
         BSODSource::DoubleFault(_) => "https://git.ablecorp.us/able/ableos/wiki/Double-Faults",
         BSODSource::Panic(_) => {
-            //
             trace!("panic");
-            "https://git.ablecorp.us/able/ableos/wiki/"
+            "https://git.ablecorp.us/able/ableos/wiki/Panic"
         }
     };
 
@@ -274,7 +282,7 @@ pub fn bsod(src: BSODSource) -> ! {
 
     mode.copy_to_buffer();
 
-    loop {}
+    sloop();
 }
 
 #[derive(Debug)]

ableos/src/experiments/y_compositor/window.rs

@@ -1,4 +1,4 @@
-use crate::driver_traits::graphics::Point;
+// use crate::driver_traits::graphics::Point;
 
 pub type MenuBar = Vec<MenuOption>;
 
@@ -8,16 +8,16 @@ pub struct MenuOption {
 
 pub struct Window {
     title: String,
-    position: Point,
+    // position: Point,
     fullscreen: bool,
 }
 
 // all of these should return a result
 impl Window {
-    pub fn new(title: String, position: Point, fullscreen: bool) -> Self {
+    pub fn new(title: String, /*position: Point,*/ fullscreen: bool) -> Self {
         Self {
             title,
-            position,
+            // position,
             fullscreen,
         }
     }
@@ -31,7 +31,7 @@ impl Window {
     pub fn set_title(&mut self) {
         todo!();
     }
-    pub fn set_position(&mut self, pos: Point) {
+    pub fn set_position(&mut self /*pos: Point*/) {
-        self.position = pos;
+        // self.position = pos;
     }
 }

ableos/src/hardware/mod.rs

@@ -0,0 +1,130 @@
+use crate::arch::interrupts::InterruptIndex;
+use crate::arch::interrupts::PICS;
+use crate::ps2_mouse::{Mouse, MouseState};
+use crate::vga_e::VGAE;
+use lazy_static::lazy_static;
+use log::info;
+use spin::Mutex;
+use vga::colors::Color16;
+use vga::writers::GraphicsWriter;
+use x86_64::instructions::port::PortReadOnly;
+use x86_64::structures::idt::InterruptStackFrame;
+
+const MOUSE_MAX_X: u16 = 638;
+const MOUSE_MAX_Y: u16 = 478;
+
+lazy_static! {
+    pub static ref _MOUSE: Mutex<Mouse> = Mutex::new(Mouse::new());
+    pub static ref MOUSE: Mutex<OnScreenMouse> = Mutex::new(OnScreenMouse::default());
+}
+
+#[derive(Default)]
+pub struct OnScreenMouse {
+    // absolute position on screen
+    x: u16,
+    // absolute position on screen
+    y: u16,
+}
+
+impl OnScreenMouse {
+    pub fn get_x(&self) -> u16 {
+        return self.x;
+    }
+
+    pub fn get_y(&self) -> u16 {
+        return self.y;
+    }
+
+    pub fn change_x(&mut self, delta_x: i16) {
+        if delta_x.is_negative() {
+            self.x = self.x.saturating_sub((-delta_x) as u16)
+        } else {
+            self.x = self.x.saturating_add(delta_x as u16)
+        }
+    }
+
+    pub fn change_y(&mut self, delta_y: i16) {
+        if delta_y.is_negative() {
+            self.y = self.y.saturating_add((-delta_y) as u16)
+        } else {
+            self.y = self.y.saturating_sub(delta_y as u16)
+        }
+    }
+    pub fn set_x(&mut self, x: u16) {
+        if x >= MOUSE_MAX_X {
+            self.x = MOUSE_MAX_X - 1;
+        } else {
+            self.x = x;
+        }
+    }
+    pub fn set_y(&mut self, y: u16) {
+        if y >= MOUSE_MAX_Y {
+            self.y = MOUSE_MAX_Y - 1;
+        } else {
+            self.y = y;
+        }
+    }
+}
+
+// Initialize the mouse and set the on complete event.
+pub fn init_mouse() {
+    let mut mouse = _MOUSE.lock();
+    // debug!("Trying to initialize mouse");
+    mouse.init().unwrap();
+    mouse.set_on_complete(on_complete);
+    // info!("Mouse initialized");
+}
+
+// This will be fired when a packet is finished being processed.
+fn on_complete(mouse_state: MouseState) {
+    // how much the cursor has moved
+    let delta_x = mouse_state.get_x();
+    let delta_y = mouse_state.get_y();
+    /*
+    trace!("MOUSE CHANGE: X{{{}}} Y{{{}}}", delta_x, delta_y);
+    trace!(
+        "MOUSE BUTTONS: LEFT{{{}}} RIGHT{{{}}}",
+        mouse_state._left_button_down(),
+        mouse_state._right_button_down()
+    );
+    */
+
+    let mut mouse = MOUSE.lock();
+    if mouse.get_x() >= MOUSE_MAX_X {
+        mouse.set_x(MOUSE_MAX_X - 1);
+    } else {
+        mouse.change_x(delta_x);
+    }
+
+    if mouse.get_y() >= MOUSE_MAX_Y {
+        mouse.set_y(MOUSE_MAX_Y - 1);
+    } else {
+        mouse.change_y(delta_y);
+    }
+    // only move the cursor when delta_x is in some range
+    // i.e. if the cursor moves too fast, ignore it.
+    // if the mouse moves too fast the delta will overflow
+    mouse.change_y(delta_y);
+
+    x86_64::instructions::interrupts::without_interrupts(|| {
+        use crate::TERM;
+        let mut term = TERM.lock();
+        term.set_dirty(true);
+    });
+
+    // draw_mouse((mouse.get_x() as usize, mouse.get_y() as usize));
+}
+
+// An example interrupt based on https://os.phil-opp.com/hardware-interrupts/.
+// The ps2 mouse is configured to fire
+// interrupts at PIC offset 12.
+pub extern "x86-interrupt" fn mouse_interrupt_handler(_stack_frame: InterruptStackFrame) {
+    let mut port = PortReadOnly::new(0x60);
+    let packet = unsafe { port.read() };
+    _MOUSE.lock().process_packet(packet);
+
+    unsafe {
+        PICS.lock()
+            .notify_end_of_interrupt(InterruptIndex::Mouse as u8);
+    }
+}

ableos/src/kmain.rs

@@ -1,6 +1,6 @@
 #![allow(clippy::empty_loop)]
 
-use core::sync::atomic::Ordering;
+use core::sync::atomic::{AtomicU64, Ordering};
 
 use crate::arch::drivers::sysinfo::master;
 use crate::ipc::channel::ChannelMessage;
@@ -13,9 +13,9 @@ use crate::{
     scratchpad,
 };
 use crate::{boot_conf::KernelConfig, systeminfo::RELEASE_TYPE};
-use crate::{wasm_jumploader, SectionType};
+use crate::{hardware, wasm_jumploader, SectionType, TERM};
 use genfs::{Fs, OpenOptions};
-use kernel::{KERNEL_VERSION, TICK};
+use kernel::KERNEL_VERSION;
 use libwasm::syscalls::time_calls::get_time;
 use qrcode::render::unicode;
 use qrcode::QrCode;
@@ -35,29 +35,43 @@ pub fn kernel_main() -> ! {
     } else {
         log::set_max_level(log::LevelFilter::Off);
     }
+    let mut term = TERM.lock();
+    term.initialize();
+    term.set_dirty(true);
+    term.draw_term();
+    drop(term);
 
+    /*
+    x86_64::instructions::interrupts::without_interrupts(|| {
+        hardware::init_mouse();
+    });
+
+    // println!("abc");
     let mut ipc_service = IPC.lock();
     // create some channels or whatever here then drop it
     let log_handle = ipc_service.create_channel("LOG", true);
     let log_sock_handle = ipc_service.create_socket("LOG", true);
 
     for handle in ipc_service.examine_board() {
-        println!("Discovered: {}", handle);
+        // println!("Discovered: {}", handle);
     }
 
     drop(ipc_service);
 
-    use x86_ata::{init, list, read, ATA_BLOCK_SIZE};
+
+    */
+
+    // use x86_ata::{init, ATA_BLOCK_SIZE};
     // 1. Initialise ATA Subsystem. (Perform Once, on boot)
-    init().expect("Failed To Start ATA...");
+    // init().expect("Failed To Start ATA...");
-    let mut buffer: [u8; ATA_BLOCK_SIZE] = [0; ATA_BLOCK_SIZE];
+    // let mut buffer: [u8; ATA_BLOCK_SIZE] = [0; ATA_BLOCK_SIZE];
     // FIXME: Calls to read panic the kernel
     // read(0, 0, 0, &mut buffer);
 
     // for abc in list() {
     //     trace!("{:?}", abc);
     // }
-
+    log_version_data();
     x86_64::instructions::interrupts::without_interrupts(|| {
         let mut scheduler = SCHEDULER.lock();
         // comment this out to resume normal use
@@ -116,9 +130,28 @@ pub fn cpu_socket_startup() {
 }
 
 pub fn log_version_data() {
-    info!("{} v{:?}", RELEASE_TYPE, KERNEL_VERSION);
+    info!("{} v{}", RELEASE_TYPE, KERNEL_VERSION);
     info!(
         "Brand String: {}",
         master().unwrap().brand_string().unwrap()
     );
 }
+
+pub static TICK: AtomicU64 = AtomicU64::new(0);
+
+pub fn tick() {
+    x86_64::instructions::interrupts::without_interrupts(|| {
+        trace!("ticking time");
+
+        let mut term = TERM.lock();
+
+        term.draw_term();
+        use core::sync::atomic::Ordering::Relaxed;
+
+        let mut data = TICK.load(Relaxed);
+        data = data.wrapping_add(1);
+
+        TICK.store(data, Relaxed);
+        trace!("time ticked");
+    });
+}

ableos/src/lib.rs

@@ -53,6 +53,7 @@ pub mod keyboard;
 pub mod kmain;
 pub mod logger;
 pub mod prelude;
+pub mod ps2_mouse;
 pub mod relib;
 pub mod rhai_shell;
 pub mod scheduler;
@@ -69,10 +70,13 @@ pub mod allocator;
 // pub use allocator as aalloc;
 pub mod channels;
 pub mod handle;
+pub mod hardware;
 pub mod ipc;
 pub mod panic;
 mod unicode_utils;
 pub mod vga_e;
+pub mod vgai;
+pub mod vterm;
 
 #[prelude_import]
 pub use prelude::rust_2021::*;

ableos/src/logger.rs

@@ -1,6 +1,7 @@
 use crate::kmain::KERNEL_CONF;
 use crate::network::socket::{SimpleSock, Socket};
 use crate::time::fetch_time;
+use alloc::borrow::ToOwned;
 use lliw::{Fg, Reset};
 use log::{Level, Metadata, Record};
 use log::{LevelFilter, SetLoggerError};
@@ -17,6 +18,8 @@ impl log::Log for SimpleLogger {
     fn log(&self, record: &Record) {
         if self.enabled(record.metadata()) {
             let time_float = fetch_time();
+            use log::Level::*;
+            use Fg::*;
 
             let color = match record.level() {
                 log::Level::Error => (Fg::Red, "$RED$"),
@@ -26,6 +29,7 @@ impl log::Log for SimpleLogger {
                 log::Level::Trace => (Fg::Yellow, "$YELLOW$"),
             };
 
+            /*
             let msg = format!(
                 "[{}{}$RESET$][$GREEN${}$RESET$]{}\n",
                 color.1,
@@ -33,29 +37,33 @@ impl log::Log for SimpleLogger {
                 time_float,
                 record.args()
             );
-            // kprint!("{}", msg);
+            */
+            let mod_path = match record.module_path() {
+                Some(p) => p,
+                None => "unknown",
+            };
+
+            let line = match record.line() {
+                Some(line_number) => line_number.to_string(),
+                None => "??".to_string(),
+            };
+
             if KERNEL_CONF.logging.log_to_serial {
                 serial_println!(
-                    "[{}{}{}][{}{}{}] {}",
+                    "[{}{}{}][{}{}{}][{}{}@{}{}] {}",
                     color.0,
                     record.level(),
                     Fg::Reset,
                     Fg::Green,
                     time_float,
                     Reset,
+                    Fg::Blue,
+                    mod_path,
+                    line,
+                    Reset,
                     record.args()
                 );
             }
-            /*
-            TODO: Get a proper socket from IPC instead of this deprecated method
-            let log_socket_id = SimpleSock::grab_socket("Logger".to_string());
-            match log_socket_id {
-                Some(mut log_socket_id) => {
-                    log_socket_id.write(msg.as_bytes().to_vec());
-                }
-                None => warn!("No socket found for Logger"),
-            }
-            */
         }
     }
     /// Clear the log buffer
@@ -64,4 +72,9 @@ impl log::Log for SimpleLogger {
 
 pub fn init() -> Result<(), SetLoggerError> {
     log::set_logger(&LOGGER).map(|()| log::set_max_level(LevelFilter::Trace))
+    // ?;
+
+    // trace!("Logger started");
+
+    // Ok(())
 }

ableos/src/prelude/rust_2021.rs

@@ -5,4 +5,5 @@ pub use core::arch::asm;
 
 pub use core::prelude::rust_2021::*;
 pub use core::prelude::v1::*;
+pub use core::result::Result::*;
 pub use log::{debug, info, trace, warn};

ableos/src/print.rs

@@ -21,8 +21,15 @@ impl core::fmt::Write for Stdout {
     }
     #[cfg(target_arch = "x86_64")]
     fn write_str(&mut self, s: &str) -> Result<(), Error> {
-        use crate::kprint;
+        use crate::TERM;
-        kprint!("{}", s);
+
+        trace!("printing");
+        x86_64::instructions::interrupts::without_interrupts(|| {
+            let mut term = TERM.lock();
+            term.set_dirty(true);
+            term.print(s.to_string());
+            drop(term);
+        });
         Ok(())
     }
     #[cfg(target_arch = "riscv64")]

ableos/src/ps2_mouse.rs

@@ -0,0 +1,300 @@
+use bitflags::bitflags;
+use x86_64::instructions::port::Port;
+
+const ADDRESS_PORT_ADDRESS: u16 = 0x64;
+const DATA_PORT_ADDRESS: u16 = 0x60;
+const GET_STATUS_BYTE: u8 = 0x20;
+const SET_STATUS_BYTE: u8 = 0x60;
+
+const DISABLE_FIRST: u8 = 0xAD;
+const DISABLE_SECOND: u8 = 0xA7;
+const ENABLE_FIRST: u8 = 0xAE;
+const ENABLE_SECOND: u8 = 0xA8;
+
+bitflags! {
+    /// Represents the flags currently set for the mouse.
+    #[derive(Default)]
+    pub struct MouseFlags: u8 {
+        /// Whether or not the left mouse button is pressed.
+        const LEFT_BUTTON = 0b0000_0001;
+
+        /// Whether or not the right mouse button is pressed.
+        const RIGHT_BUTTON = 0b0000_0010;
+
+        /// Whether or not the middle mouse button is pressed.
+        const MIDDLE_BUTTON = 0b0000_0100;
+
+        /// Whether or not the packet is valid or not.
+        const ALWAYS_ONE = 0b0000_1000;
+
+        /// Whether or not the x delta is negative.
+        const X_SIGN = 0b0001_0000;
+
+        /// Whether or not the y delta is negative.
+        const Y_SIGN = 0b0010_0000;
+
+        /// Whether or not the x delta overflowed.
+        const X_OVERFLOW = 0b0100_0000;
+
+        /// Whether or not the y delta overflowed.
+        const Y_OVERFLOW = 0b1000_0000;
+    }
+}
+
+#[repr(u8)]
+enum Command {
+    EnablePacketStreaming = 0xF4,
+    SetDefaults = 0xF6,
+}
+
+/// A basic interface to interact with a PS2 mouse.
+#[derive(Debug)]
+pub struct Mouse {
+    command_port: Port<u8>,
+    data_port: Port<u8>,
+    current_packet: u8,
+    current_state: MouseState,
+    completed_state: MouseState,
+    on_complete: Option<fn(MouseState)>,
+}
+
+impl Default for Mouse {
+    fn default() -> Mouse {
+        Mouse::new()
+    }
+}
+
+/// A snapshot of the mouse flags, x delta and y delta.
+#[derive(Debug, Copy, Clone, Default)]
+pub struct MouseState {
+    flags: MouseFlags,
+    x: i16,
+    y: i16,
+}
+
+impl MouseState {
+    /// Returns a new `MouseState`.
+    pub const fn new() -> MouseState {
+        MouseState {
+            flags: MouseFlags::empty(),
+            x: 0,
+            y: 0,
+        }
+    }
+
+    /// Returns true if the left mouse button is currently down.
+    pub fn _left_button_down(&self) -> bool {
+        self.flags.contains(MouseFlags::LEFT_BUTTON)
+    }
+
+    /// Returns true if the left mouse button is currently up.
+    pub fn _left_button_up(&self) -> bool {
+        !self.flags.contains(MouseFlags::LEFT_BUTTON)
+    }
+
+    /// Returns true if the right mouse button is currently down.
+    pub fn _right_button_down(&self) -> bool {
+        self.flags.contains(MouseFlags::RIGHT_BUTTON)
+    }
+
+    /// Returns true if the right mouse button is currently up.
+    pub fn _right_button_up(&self) -> bool {
+        !self.flags.contains(MouseFlags::RIGHT_BUTTON)
+    }
+
+    /// Returns true if the x axis has moved.
+    pub fn _x_moved(&self) -> bool {
+        self.x != 0
+    }
+
+    /// Returns true if the y axis has moved.
+    pub fn _y_moved(&self) -> bool {
+        self.y != 0
+    }
+
+    /// Returns true if the x or y axis has moved.
+    pub fn _moved(&self) -> bool {
+        self._x_moved() || self._y_moved()
+    }
+
+    /// Returns the x delta of the mouse state.
+    pub fn get_x(&self) -> i16 {
+        self.x
+    }
+
+    /// Returns the y delta of the mouse state.
+    pub fn get_y(&self) -> i16 {
+        self.y
+    }
+}
+
+impl Mouse {
+    /// Creates a new `Mouse`.
+    pub const fn new() -> Mouse {
+        Mouse {
+            command_port: Port::new(ADDRESS_PORT_ADDRESS),
+            data_port: Port::new(DATA_PORT_ADDRESS),
+            current_packet: 0,
+            current_state: MouseState::new(),
+            completed_state: MouseState::new(),
+            on_complete: None,
+        }
+    }
+
+    /// Returns the last completed state of the mouse.
+    pub fn _get_state(&self) -> MouseState {
+        self.completed_state
+    }
+
+    // super helpful resource, albeit in C
+    // https://github.com/29jm/SnowflakeOS/blob/master/kernel/src/devices/ps2.c#L18
+    /// Attempts to initialize a `Mouse`. If successful, interrupts will be generated
+    /// as `PIC offset + 12`.
+    pub fn init(&mut self) -> Result<(), &'static str> {
+        // Disable both PS/2 device ports
+        // Even if only one is present, disabling the second is harmless
+        self.write_command_port(DISABLE_FIRST)?;
+        self.write_command_port(DISABLE_SECOND)?;
+
+        // Flush output buffer: if the controller had anything to say, ignore it
+        unsafe {
+            self.data_port.read();
+        }
+
+        debug!("mouse driver: writing GET_STATUS to port...");
+        self.write_command_port(GET_STATUS_BYTE)?;
+        debug!("mouse driver: reading status from port...");
+        let status = self.read_data_port()? | 0x02;
+
+        debug!("Got status {}", status);
+
+        // self.write_command_port(0xa8)?;
+
+        self.write_command_port(SET_STATUS_BYTE)?;
+
+        self.write_data_port(status & 0xDF)?;
+
+        self.send_command(Command::SetDefaults)?;
+        self.send_command(Command::EnablePacketStreaming)?;
+
+        self.write_command_port(ENABLE_FIRST)?;
+        self.write_command_port(ENABLE_SECOND)?;
+
+        // Some keyboards actually send a reply, flush it
+        unsafe {
+            self.data_port.read();
+        }
+
+        Ok(())
+    }
+
+    /// Attempts to process a packet.
+    pub fn process_packet(&mut self, packet: u8) {
+        match self.current_packet {
+            0 => {
+                let flags = MouseFlags::from_bits_truncate(packet);
+                if !flags.contains(MouseFlags::ALWAYS_ONE) {
+                    return;
+                }
+                self.current_state.flags = flags;
+            }
+            1 => self.process_x_movement(packet),
+            2 => {
+                self.process_y_movement(packet);
+                self.completed_state = self.current_state;
+                if let Some(on_complete) = self.on_complete {
+                    on_complete(self.completed_state);
+                }
+            }
+            _ => unreachable!(),
+        }
+        self.current_packet = (self.current_packet + 1) % 3;
+    }
+
+    /// Sets the `on_complete` function to be called when a packet is completed.
+    pub fn set_on_complete(&mut self, handler: fn(MouseState)) {
+        self.on_complete = Some(handler);
+    }
+
+    fn process_x_movement(&mut self, packet: u8) {
+        if !self.current_state.flags.contains(MouseFlags::X_OVERFLOW) {
+            self.current_state.x = if self.current_state.flags.contains(MouseFlags::X_SIGN) {
+                self.sign_extend(packet)
+            } else {
+                packet as i16
+            };
+        }
+    }
+
+    fn process_y_movement(&mut self, packet: u8) {
+        if !self.current_state.flags.contains(MouseFlags::Y_OVERFLOW) {
+            self.current_state.y = if self.current_state.flags.contains(MouseFlags::Y_SIGN) {
+                self.sign_extend(packet)
+            } else {
+                packet as i16
+            };
+        }
+    }
+
+    fn read_data_port(&mut self) -> Result<u8, &'static str> {
+        // INFO: What the fuck
+        debug!("owo");
+        self.wait_for_read()?;
+        // HERESY: Stop
+        debug!("what's this");
+        Ok(unsafe { self.data_port.read() })
+    }
+
+    fn send_command(&mut self, command: Command) -> Result<(), &'static str> {
+        self.write_command_port(0xD4)?;
+        self.write_data_port(command as u8)?;
+        if self.read_data_port()? != 0xFA {
+            return Err("mouse did not respond to the command");
+        }
+        Ok(())
+    }
+
+    fn sign_extend(&self, packet: u8) -> i16 {
+        ((packet as u16) | 0xFF00) as i16
+    }
+
+    fn write_command_port(&mut self, value: u8) -> Result<(), &'static str> {
+        debug!("mouse driver: waiting for write");
+        self.wait_for_write()?;
+        unsafe {
+            self.command_port.write(value);
+        }
+        debug!("mouse driver: command written");
+        Ok(())
+    }
+
+    fn write_data_port(&mut self, value: u8) -> Result<(), &'static str> {
+        self.wait_for_write()?;
+        unsafe {
+            self.data_port.write(value);
+        }
+        Ok(())
+    }
+
+    fn wait_for_read(&mut self) -> Result<(), &'static str> {
+        let timeout = 100_000;
+        for _x in 0..timeout {
+            let value = unsafe { self.command_port.read() };
+            if (value & 0x1) == 0x1 {
+                return Ok(());
+            }
+        }
+        Err("wait for mouse read timeout")
+    }
+
+    fn wait_for_write(&mut self) -> Result<(), &'static str> {
+        let timeout = 100_000;
+        for _ in 0..timeout {
+            let value = unsafe { self.command_port.read() };
+            if (value & 0x2) == 0x0 {
+                return Ok(());
+            }
+        }
+        Err("wait for mouse write timeout")
+    }
+}

ableos/src/scratchpad.rs

@@ -10,8 +10,9 @@ use crate::handle::Handle;
 use crate::ipc::IPC;
 use crate::rhai_shell::shell;
 use crate::rhai_shell::KEYBUFF;
+use crate::vterm::Term;
 use crate::wasm_jumploader::run_program;
-use crate::SCREEN_BUFFER;
+use crate::{vgai, SCREEN_BUFFER};
 use acpi::{AcpiTables, PlatformInfo};
 use alloc::collections::{vec_deque, VecDeque};
 use cpuio::inb;
@@ -24,6 +25,7 @@ use genfs::OpenOptions;
 use genfs::{DirEntry, Fs};
 use kernel::proccess::PID;
 use kernel::software_int;
+use spin::Lazy;
 use vga::writers::GraphicsWriter;
 
 // TODO: move to a better place
@@ -43,6 +45,8 @@ impl acpi::AcpiHandler for AcpiStruct {
         todo!("unmap_physical_region");
     }
 }
+
+pub static TERM: Lazy<spin::Mutex<Term>> = Lazy::new(|| spin::Mutex::new(Term::new()));
 #[derive(Debug)]
 
 pub struct Path {
@@ -65,50 +69,8 @@ impl Path {
 
 /// Experimental scratchpad for testing.
 pub fn scratchpad() {
-    let axel_raw = "kernel{
-    vals=
-        time: 123
-    fn|
-        print: (None) -> (None);
-        foo: (None) -> (Num); 
-}";
-
-    let axel = axel::parse(axel_raw.to_string());
-
-    // software_int();
-
-    // let xyz = pci::brute_force_scan();
-    // for dev in xyz {
-    //     trace!("{:?}", dev);
-    //     dev.bars.iter().for_each(|bar| {
-    //         trace!("{:?}", bar);
-    //     });
-    // }
-
-    for node in axel {
-        info!("{:?}", node);
-    }
-    /*
-    use crate::devices::pci::brute_force_scan;
-    let infos = brute_force_scan();
-    for device in infos {
-        match device.vendor_id {
-            0x1af4 => {
-                info!("Found virtio device");
-                use crate::virtio::device_handler;
-                device_handler(device);
-            }
-            _ => {
-                info!("Found unknown device");
-            }
-        }
-    }
-
-    */
-
     real_shell();
 }
-use crate::graphics::VgaBuffer;
 
 pub fn acpi() {
     let acpi_handler = AcpiStruct {};

ableos/src/time.rs

@@ -1,5 +1,5 @@
+use crate::kmain::TICK;
 use core::sync::atomic::Ordering;
-use kernel::TICK;
 
 #[cfg(target_arch = "x86_64")]
 pub fn fetch_time() -> f64 {

ableos/src/vgai.rs

@@ -0,0 +1,64 @@
+use vga::writers::{Graphics640x480x16, GraphicsWriter};
+
+pub enum Color {
+    /// Represents the color `Black (0x0)`.
+    Black = 0x0,
+    /// Represents the color `Blue (0x1)`.
+    Blue = 0x1,
+    /// Represents the color `Green (0x2)`.
+    Green = 0x2,
+    /// Represents the color `Cyan (0x3)`.
+    Cyan = 0x3,
+    /// Represents the color `Red (0x4)`.
+    Red = 0x4,
+    /// Represents the color `Magenta (0x5)`.
+    Magenta = 0x5,
+    /// Represents the color `Brown (0x6)`.
+    Brown = 0x6,
+    /// Represents the color `LightGrey (0x7)`.
+    LightGrey = 0x7,
+    /// Represents the color `DarkGrey (0x8)`.
+    DarkGrey = 0x8,
+    /// Represents the color `LightBlue (0x9)`.
+    LightBlue = 0x9,
+    /// Represents the color `LightGreen (0xA)`.
+    LightGreen = 0xA,
+    /// Represents the color `LightCyan (0xB)`.
+    LightCyan = 0xB,
+    /// Represents the color `LightRed (0xC)`.
+    LightRed = 0xC,
+    /// Represents the color `Pink (0xD)`.
+    Pink = 0xD,
+    /// Represents the color `Yellow (0xE)`.
+    Yellow = 0xE,
+    /// Represents the color `White (0xF)`.
+    White = 0xF,
+}
+
+const VGA_BUFFER_SIZE: usize = 480;
+
+pub struct ScreenBuffer {}
+impl ScreenBuffer {
+    pub fn initialise() {}
+
+    pub fn flip_buffer() {
+        /*
+        before doing anything past here we need to tell the VGA about some things
+        */
+        let setup = false;
+        if setup {
+            use Color::*;
+            let dualpixel: u8 = Red as u8;
+
+            let buff: [u8; VGA_BUFFER_SIZE] = [dualpixel; VGA_BUFFER_SIZE];
+
+            let buff_ptr = buff.as_ptr();
+            let vga_buffer = 0xb8000 as *mut u8;
+
+            use core::ptr;
+            unsafe {
+                ptr::copy(buff_ptr, vga_buffer, VGA_BUFFER_SIZE);
+            }
+        }
+    }
+}

ableos/src/vterm.rs

@@ -0,0 +1,100 @@
+use vga::{colors::Color16, writers::GraphicsWriter};
+
+use crate::{
+    hardware::{MOUSE, _MOUSE},
+    vga_e::VGAE,
+};
+const TERM_MINUS_ONE_LINE: usize = 4720;
+const CURSOR_COLOR: Color16 = Color16::Cyan;
+
+#[derive(Debug)]
+pub struct Term {
+    dirty: bool,
+    term: [char; 80 * 60],
+    x: usize,
+}
+impl Term {
+    pub fn new() -> Self {
+        Self {
+            dirty: false,
+            x: 0,
+            term: ['\0'; 80 * 60],
+        }
+    }
+    pub fn is_dirty(&self) -> bool {
+        self.dirty
+    }
+
+    pub fn set_dirty(&mut self, dirty: bool) {
+        self.dirty = dirty
+    }
+
+    pub fn print(&mut self, data: String) {
+        for c in data.chars() {
+            if self.x == 79 || c == '\n' {
+                self.move_up();
+                self.x = 0;
+            } else {
+                self.term[TERM_MINUS_ONE_LINE + self.x] = c;
+                self.x += 1;
+            }
+        }
+    }
+    pub fn move_up(&mut self) {
+        self.term.rotate_left(80);
+        for x in 0..80 {
+            self.term[TERM_MINUS_ONE_LINE + x] = '\0';
+        }
+    }
+    pub fn initialize(&self) {
+        let mode = VGAE.lock();
+        mode.set_mode();
+        drop(mode);
+    }
+
+    pub fn draw_term(&mut self) {
+        if self.is_dirty() {
+            trace!("Redrawing");
+            let mode = VGAE.lock();
+            mode.clear_screen(Color16::Black);
+
+            let mouse_coord = x86_64::instructions::interrupts::without_interrupts(|| {
+                let cursor = MOUSE.lock();
+
+                (cursor.get_x() as usize, cursor.get_y() as usize)
+            });
+
+            mode.draw_line(
+                (mouse_coord.0 as isize + 0, mouse_coord.1 as isize + 0),
+                (mouse_coord.0 as isize + 10, mouse_coord.1 as isize + 10),
+                CURSOR_COLOR,
+            );
+            mode.draw_line(
+                (mouse_coord.0 as isize + 0, mouse_coord.1 as isize + 0),
+                (mouse_coord.0 as isize + 5, mouse_coord.1 as isize + 0),
+                CURSOR_COLOR,
+            );
+            mode.draw_line(
+                (mouse_coord.0 as isize + 0, mouse_coord.1 as isize + 0),
+                (mouse_coord.0 as isize + 0, mouse_coord.1 as isize + 5),
+                CURSOR_COLOR,
+            );
+
+            let mut x = 0;
+            let mut y = 0;
+
+            for c in self.term {
+                mode.draw_character(x * 8, y * 8, c, Color16::White);
+
+                if x == 79 {
+                    y += 1;
+                    x = 0;
+                } else {
+                    x += 1
+                }
+            }
+            self.set_dirty(true);
+            trace!("Finished drawing");
+        }
+    }
+}

ableos/src/wasm_jumploader/host_functions.rs

@@ -136,7 +136,7 @@ host_externals! {
         trace!("SYSCALL: get time");
 
         x86_64::instructions::interrupts::disable();
-        let tick_time = kernel::TICK.load(Relaxed);
+        let tick_time = crate::kmain::TICK.load(Relaxed);
         x86_64::instructions::interrupts::enable();
 
         let ret: u32 = tick_time.try_into().unwrap();

kernel/src/lib.rs

@@ -25,7 +25,7 @@ use core::{
 use versioning::Version;
 
 /// The number of ticks since the first CPU was started
-pub static TICK: AtomicU64 = AtomicU64::new(0);
+// pub static TICK: AtomicU64 = AtomicU64::new(0);
 
 /// Kernel's version
 pub const KERNEL_VERSION: Version = Version {
@@ -34,6 +34,7 @@ pub const KERNEL_VERSION: Version = Version {
     patch: 2,
 };
 
+/*
 /// called by arch specific timers to tick up all kernel related functions
 pub fn tick() {
     let mut data = TICK.load(Relaxed);
@@ -41,7 +42,7 @@ pub fn tick() {
 
     TICK.store(data, Relaxed)
 }
-
+*/
 /// Cause a software interrupt
 pub fn software_int() {
     unsafe { asm!("int 54") }

qmp.py

@@ -0,0 +1,243 @@
+# QEMU Monitor Protocol Python class
+#
+# Copyright (C) 2009, 2010 Red Hat Inc.
+#
+# Authors:
+#  Luiz Capitulino <lcapitulino@redhat.com>
+#
+# This work is licensed under the terms of the GNU GPL, version 2.  See
+# the COPYING file in the top-level directory.
+
+import json
+import errno
+import socket
+import logging
+
+
+class QMPError(Exception):
+    pass
+
+
+class QMPConnectError(QMPError):
+    pass
+
+
+class QMPCapabilitiesError(QMPError):
+    pass
+
+
+class QMPTimeoutError(QMPError):
+    pass
+
+
+class QEMUMonitorProtocol(object):
+
+    #: Logger object for debugging messages
+    logger = logging.getLogger('QMP')
+    #: Socket's error class
+    error = socket.error
+    #: Socket's timeout
+    timeout = socket.timeout
+
+    def __init__(self, address, server=False):
+        """
+        Create a QEMUMonitorProtocol class.
+        @param address: QEMU address, can be either a unix socket path (string)
+                        or a tuple in the form ( address, port ) for a TCP
+                        connection
+        @param server: server mode listens on the socket (bool)
+        @raise socket.error on socket connection errors
+        @note No connection is established, this is done by the connect() or
+              accept() methods
+        """
+        self.__events = []
+        self.__address = address
+        self.__sock = self.__get_sock()
+        self.__sockfile = None
+        if server:
+            self.__sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+            self.__sock.bind(self.__address)
+            self.__sock.listen(1)
+
+    def __get_sock(self):
+        if isinstance(self.__address, tuple):
+            family = socket.AF_INET
+        else:
+            family = socket.AF_UNIX
+        return socket.socket(family, socket.SOCK_STREAM)
+
+    def __negotiate_capabilities(self):
+        greeting = self.__json_read()
+        if greeting is None or "QMP" not in greeting:
+            raise QMPConnectError
+        # Greeting seems ok, negotiate capabilities
+        resp = self.cmd('qmp_capabilities')
+        if "return" in resp:
+            return greeting
+        raise QMPCapabilitiesError
+
+    def __json_read(self, only_event=False):
+        while True:
+            data = self.__sockfile.readline()
+            if not data:
+                return
+            resp = json.loads(data)
+            if 'event' in resp:
+                self.logger.debug("<<< %s", resp)
+                self.__events.append(resp)
+                if not only_event:
+                    continue
+            return resp
+
+    def __get_events(self, wait=False):
+        """
+        Check for new events in the stream and cache them in __events.
+        @param wait (bool): block until an event is available.
+        @param wait (float): If wait is a float, treat it as a timeout value.
+        @raise QMPTimeoutError: If a timeout float is provided and the timeout
+                                period elapses.
+        @raise QMPConnectError: If wait is True but no events could be
+                                retrieved or if some other error occurred.
+        """
+
+        # Check for new events regardless and pull them into the cache:
+        self.__sock.setblocking(0)
+        try:
+            self.__json_read()
+        except socket.error as err:
+            if err[0] == errno.EAGAIN:
+                # No data available
+                pass
+        self.__sock.setblocking(1)
+
+        # Wait for new events, if needed.
+        # if wait is 0.0, this means "no wait" and is also implicitly false.
+        if not self.__events and wait:
+            if isinstance(wait, float):
+                self.__sock.settimeout(wait)
+            try:
+                ret = self.__json_read(only_event=True)
+            except socket.timeout:
+                raise QMPTimeoutError("Timeout waiting for event")
+            except:
+                raise QMPConnectError("Error while reading from socket")
+            if ret is None:
+                raise QMPConnectError("Error while reading from socket")
+            self.__sock.settimeout(None)
+
+    def connect(self, negotiate=True):
+        """
+        Connect to the QMP Monitor and perform capabilities negotiation.
+        @return QMP greeting dict
+        @raise socket.error on socket connection errors
+        @raise QMPConnectError if the greeting is not received
+        @raise QMPCapabilitiesError if fails to negotiate capabilities
+        """
+        self.__sock.connect(self.__address)
+        self.__sockfile = self.__sock.makefile()
+        if negotiate:
+            return self.__negotiate_capabilities()
+
+    def accept(self):
+        """
+        Await connection from QMP Monitor and perform capabilities negotiation.
+        @return QMP greeting dict
+        @raise socket.error on socket connection errors
+        @raise QMPConnectError if the greeting is not received
+        @raise QMPCapabilitiesError if fails to negotiate capabilities
+        """
+        self.__sock.settimeout(15)
+        self.__sock, _ = self.__sock.accept()
+        self.__sockfile = self.__sock.makefile()
+        return self.__negotiate_capabilities()
+
+    def cmd_obj(self, qmp_cmd):
+        """
+        Send a QMP command to the QMP Monitor.
+        @param qmp_cmd: QMP command to be sent as a Python dict
+        @return QMP response as a Python dict or None if the connection has
+                been closed
+        """
+        self.logger.debug(">>> %s", qmp_cmd)
+        try:
+            self.__sock.sendall(json.dumps(qmp_cmd).encode('utf-8'))
+        except socket.error as err:
+            if err[0] == errno.EPIPE:
+                return
+            raise socket.error(err)
+        resp = self.__json_read()
+        self.logger.debug("<<< %s", resp)
+        return resp
+
+    def cmd(self, name, args=None, cmd_id=None):
+        """
+        Build a QMP command and send it to the QMP Monitor.
+        @param name: command name (string)
+        @param args: command arguments (dict)
+        @param cmd_id: command id (dict, list, string or int)
+        """
+        qmp_cmd = {'execute': name}
+        if args:
+            qmp_cmd['arguments'] = args
+        if cmd_id:
+            qmp_cmd['id'] = cmd_id
+        return self.cmd_obj(qmp_cmd)
+
+    def command(self, cmd, **kwds):
+        """
+        Build and send a QMP command to the monitor, report errors if any
+        """
+        ret = self.cmd(cmd, kwds)
+        if "error" in ret:
+            raise Exception(ret['error']['desc'])
+        return ret['return']
+
+    def pull_event(self, wait=False):
+        """
+        Pulls a single event.
+        @param wait (bool): block until an event is available.
+        @param wait (float): If wait is a float, treat it as a timeout value.
+        @raise QMPTimeoutError: If a timeout float is provided and the timeout
+                                period elapses.
+        @raise QMPConnectError: If wait is True but no events could be
+                                retrieved or if some other error occurred.
+        @return The first available QMP event, or None.
+        """
+        self.__get_events(wait)
+
+        if self.__events:
+            return self.__events.pop(0)
+        return None
+
+    def get_events(self, wait=False):
+        """
+        Get a list of available QMP events.
+        @param wait (bool): block until an event is available.
+        @param wait (float): If wait is a float, treat it as a timeout value.
+        @raise QMPTimeoutError: If a timeout float is provided and the timeout
+                                period elapses.
+        @raise QMPConnectError: If wait is True but no events could be
+                                retrieved or if some other error occurred.
+        @return The list of available QMP events.
+        """
+        self.__get_events(wait)
+        return self.__events
+
+    def clear_events(self):
+        """
+        Clear current list of pending events.
+        """
+        self.__events = []
+
+    def close(self):
+        self.__sock.close()
+        self.__sockfile.close()
+
+    def settimeout(self, timeout):
+        self.__sock.settimeout(timeout)
+
+    def get_sock_fd(self):
+        return self.__sock.fileno()
+
+    def is_scm_available(self):
+        return self.__sock.family == socket.AF_UNIX

qprofiler.py

@@ -0,0 +1,118 @@
+#!/usr/bin/python
+#
+# QProfiler is a QEMU profiler based on QMP
+#
+# Copyright (c) 2019-2022 Matias Vara <matiasevara@gmail.com>
+# All Rights Reserved
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+from __future__ import print_function
+import sys, os, re
+from qmp import QEMUMonitorProtocol
+from time import sleep
+import subprocess
+
+def main(args):
+  path = None
+  filename = None
+
+  # duration of the test in seconds
+  duration = 5
+
+  # sampling frequency in seconds
+  frequency = 0.05
+
+  while len(args):
+    arg = args[0]
+
+    if arg.startswith('--'):
+      arg = arg[2:]
+      if arg.find('=') == -1:
+        value = True
+      else:
+        arg, value = arg.split('=', 1)
+
+      if arg in ['path']:
+        if type(value) == str:
+          path = value
+      elif arg in ['duration']:
+        duration = int(value)
+      elif arg in ['frequency']:
+        frequency = float(value)
+      elif arg in ['filename']:
+        filename = value
+      else:
+        print('Unknown argument "%s"' % arg)
+        return 1
+
+      args = args[1:]
+    else:
+      break
+
+  if not path:
+    print("Path isn't set, use --path=qmp-monitor-address")
+    return 1
+    
+  def do_command(srv, cmd, **kwds):
+    rsp = srv.cmd(cmd, kwds)
+    if 'error' in rsp:
+      raise Exception(rsp['error']['desc'])
+    return rsp['return']
+
+  srv = QEMUMonitorProtocol(path)
+  srv.connect()
+
+  arguments = {}
+  command = 'human-monitor-command'
+
+  r = int(duration // frequency)
+    
+  rip_hash = {}
+ 
+  for i in range(r):
+    arguments['command-line'] = 'info registers'
+    rsp = do_command(srv, command, **arguments)
+      
+    regs = re.search(r'RIP=([\w]+)\s', rsp)
+    rip = regs.group(1)
+      
+    if rip in rip_hash:
+      rip_hash[rip] += 1
+    else:
+      rip_hash[rip] = 1
+
+    sleep(frequency)
+ 
+  srv.close()
+  rip_hash_name = {}
+
+  for i in rip_hash:
+      with open(os.devnull, 'w') as devnull:
+          # pass
+          tmp = subprocess.check_output("addr2line --demangle -p -s -f -e "
+          + filename
+          + " " 
+          + i , shell=True, stderr=devnull).rstrip()
+
+      if tmp in rip_hash_name:
+        rip_hash_name[tmp] += rip_hash[i]
+      else:
+        rip_hash_name[tmp] = rip_hash[i]
+
+  for i in rip_hash_name:
+    print('{:>8} {}'.format(rip_hash_name[i], i))
+
+if __name__ == '__main__':
+  sys.exit(main(sys.argv[1:]))

repbuild/src/main.rs

@@ -11,6 +11,8 @@ enum Command {
     Run {
         #[clap(long, short)]
         debug: bool,
+        #[clap(long, short)]
+        profile: bool,
 
         #[clap(long, short, arg_enum)]
         machine: Option<MachineType>,
@@ -44,7 +46,12 @@ fn main() -> anyhow::Result<()> {
     let args = Command::parse();
 
     match args {
-        Command::Run { debug, machine } => {
+        Command::Run {
+            debug,
+            profile,
+
+            machine,
+        } => {
             let _dir = xshell::pushd("./ableos");
 
             let _debug_log: &[&str] = match debug {
@@ -54,6 +61,9 @@ fn main() -> anyhow::Result<()> {
             match machine.unwrap_or(MachineType::X86) {
                 MachineType::X86 => {
                     xshell::cmd!("cargo run --release").run()?;
+                    if profile {
+                        xshell::cmd!("python qprofiler.py --path=qmp-sock --filename=target/x86_64-ableos/release/ableos").run()?;
+                    }
                 }
                 MachineType::Arm => {
                     xshell::cmd!("cargo build --release --target=json_targets/aarch64-ableos.json")