9 files changed, 31 insertions, 208 deletions

diff --git a/src/font.rs b/rsnix/src/font.rs
index e188513..e188513 100644
--- a/src/font.rs
+++ b/rsnix/src/font.rs
diff --git a/src/gop.rs b/rsnix/src/gop.rs
index 9645bb0..9645bb0 100644
--- a/src/gop.rs
+++ b/rsnix/src/gop.rs
diff --git a/src/interrupts.rs b/rsnix/src/interrupts.rs
index 90d5bbb..8f2acd7 100644
--- a/src/interrupts.rs
+++ b/rsnix/src/interrupts.rs
@@ -174,7 +174,7 @@ impl KeyBuf {
         let h = self.head.load(Ordering::Acquire);
         let next = t.wrapping_add(1);
         // Full if the distance between head and tail == capacity (256).
-        if next.wrapping_sub(h) as u16 > 255 {
+        if next.wrapping_sub(h) > 255 {
             return; // drop — ring is full
         }
         unsafe {
@@ -362,7 +362,7 @@ pub fn init() {
 
         // Build the IDTR pseudo-descriptor.
         IDTR = [
-            (256u16 * 16 - 1) as u16,      // limit = 256*16 - 1
+            ((256u16 * 16 - 1)),      // limit = 256*16 - 1
             idt_ptr as u16,                // base lo
             (idt_ptr as u64 >> 16) as u16, // base mid
             (idt_ptr as u64 >> 32) as u16, // base hi
diff --git a/src/memory.rs b/rsnix/src/memory.rs
index d223f69..39fd88d 100644
--- a/src/memory.rs
+++ b/rsnix/src/memory.rs
@@ -85,7 +85,7 @@ pub fn capture_memory_map(bs: &BootServices) -> Result<usize, Status> {
     }
 
     // Round up to desc_size alignment
-    let buf_size = (buf_size + desc_size - 1) / desc_size * desc_size;
+    let buf_size = buf_size.div_ceil(desc_size) * desc_size;
 
     // If our static buffer is too small, fall back to pool (rare)
     if buf_size > unsafe { MAP_WORK_BUF.len() } {
diff --git a/src/ps2.rs b/rsnix/src/ps2.rs
index 4ea8b7a..b83a4e0 100644
--- a/src/ps2.rs
+++ b/rsnix/src/ps2.rs
@@ -346,11 +346,10 @@ fn update_modifiers(scancode: u8, pressed: bool, e0: bool) {
         (0x1D, true) => set_mod(state, MOD_RCTRL, pressed),
         (0x38, false) => set_mod(state, MOD_LALT, pressed),
         (0x38, true) => set_mod(state, MOD_RALT, pressed),
-        (0x3A, false) => {
-            if pressed {
+        (0x3A, false)
+            if pressed => {
                 state.modifiers ^= MOD_CAPS;
             }
-        }
         _ => {}
     }
 }
diff --git a/src/serial.rs b/rsnix/src/serial.rs
index 03fa570..03fa570 100644
--- a/src/serial.rs
+++ b/rsnix/src/serial.rs
diff --git a/src/uefi.rs b/rsnix/src/uefi.rs
index 2e3ed6b..2e3ed6b 100644
--- a/src/uefi.rs
+++ b/rsnix/src/uefi.rs
diff --git a/src/shell.rs b/shell/src/lib.rs
index 8e4cb62..bdd79c6 100644
--- a/src/shell.rs
+++ b/shell/src/lib.rs
@@ -1,14 +1,24 @@
+#![no_std]
+
+extern crate alloc;
+
 /// Minimal command shell — reads from PS/2 keyboard, writes to GOP + serial.
-use crate::ps2::{self, KeyEvent};
-use crate::{gop_print, gop_println, serial_print, serial_println};
+use rsnix::ps2::{self, KeyEvent};
+use rsnix::{gop_print, gop_println, serial_print, serial_println};
 
 /// Maximum input line length.
 const LINE_BUF_SIZE: usize = 256;
 
 /// Run the shell forever.
 pub fn run() -> ! {
-    gop_println!("raisernics v{} — type 'help' for commands", env!("CARGO_PKG_VERSION"));
-    serial_println!("========== raisernics v{} ==========", env!("CARGO_PKG_VERSION"));
+    gop_println!(
+        "rs-dos v{} — type 'help' for commands",
+        env!("CARGO_PKG_VERSION")
+    );
+    serial_println!(
+        "========== rs-dos v{} ==========",
+        env!("CARGO_PKG_VERSION")
+    );
 
     loop {
         // Print prompt
@@ -53,32 +63,32 @@ fn read_line() -> heapless_str::String<LINE_BUF_SIZE> {
     loop {
         match ps2::poll_key() {
             KeyEvent::Enter => {
-                crate::gop::put_char('\n');
-                crate::serial::write_str("\r\n");
+                rsnix::gop::put_char('\n');
+                rsnix::serial::write_str("\r\n");
                 return buf;
             }
             KeyEvent::Char(c) if c.is_ascii_graphic() || c == ' ' => {
                 if buf.push(c).is_ok() {
-                    crate::gop::put_char(c);
+                    rsnix::gop::put_char(c);
                     // Echo to serial too
                     let mut s = [0u8; 4];
                     let s = c.encode_utf8(&mut s);
-                    crate::serial::write_str(s);
+                    rsnix::serial::write_str(s);
                 }
             }
             KeyEvent::Backspace => {
                 if buf.pop().is_some() {
                     // GOP backspace: move cursor back and erase
-                    crate::gop::put_char('\x08');
+                    rsnix::gop::put_char('\x08');
                     // Serial backspace: send BS SP BS (standard terminal protocol)
-                    crate::serial::write_str("\x08 \x08");
+                    rsnix::serial::write_str("\x08 \x08");
                 }
             }
             KeyEvent::Tab => {
                 for _ in 0..4 {
                     if buf.push(' ').is_ok() {
-                        crate::gop::put_char(' ');
-                        crate::serial::write_str(" ");
+                        rsnix::gop::put_char(' ');
+                        rsnix::serial::write_str(" ");
                     }
                 }
             }
@@ -120,14 +130,14 @@ fn cmd_echo(args: &str) {
 }
 
 fn cmd_clear() {
-    crate::gop::clear_screen();
+    rsnix::gop::clear_screen();
 }
 
 fn cmd_info() {
     // Test that the global allocator works: build a String on the heap
-    let mut s = alloc::string::String::from("raisernics v");
+    let mut s = alloc::string::String::from("rs-dos v");
     s.push_str(env!("CARGO_PKG_VERSION"));
-    s.push_str(" — RNG custom kernel");
+    s.push_str(" — rsnix kernel");
     gop_println!("{}", s);
     gop_println!("arch: x86_64, freestanding, no userspace");
     serial_println!("{}", s);
@@ -136,7 +146,7 @@ fn cmd_info() {
 }
 
 fn cmd_mem() {
-    let (map, key) = crate::memory::get_map();
+    let (map, key) = rsnix::memory::get_map();
 
     let mut total_kb = 0u64;
     let mut conventional_kb = 0u64;
diff --git a/src/main.rs b/src/main.rs
deleted file mode 100644
index 9a901f5..0000000
--- a/src/main.rs
+++ /dev/null
@@ -1,186 +0,0 @@
-#![no_std]
-#![no_main]
-#![allow(static_mut_refs, unsafe_code, dead_code, unused_doc_comments)]
-
-// SAFETY: single-core kernel, no preemption — static mut access is sound
-// Toy kernel: dead code and unused items during active development
-
-extern crate alloc;
-
-mod font;
-mod gop;
-mod interrupts;
-mod memory;
-mod ps2;
-mod serial;
-mod shell;
-mod uefi;
-
-use core::panic::PanicInfo;
-use uefi::*;
-
-// ---------------------------------------------------------------------------
-// Panic handler
-// ---------------------------------------------------------------------------
-#[panic_handler]
-fn panic(info: &PanicInfo) -> ! {
-    use core::fmt::Write;
-    serial::write_str("\r\n*** PANIC ***\r\n");
-    let _ = write!(&mut serial::SerialWriter, "{}\r\n", info.message());
-    if let Some(loc) = info.location() {
-        let _ = write!(
-            &mut serial::SerialWriter,
-            "  at {}:{}\r\n",
-            loc.file(),
-            loc.line()
-        );
-    }
-    loop {
-        unsafe {
-            core::arch::asm!("cli; hlt");
-        }
-    }
-}
-
-// ---------------------------------------------------------------------------
-// EFI entry point
-// ---------------------------------------------------------------------------
-#[no_mangle]
-pub extern "efiapi" fn efi_main(image_handle: Handle, system_table: *mut SystemTable) -> ! {
-    let st = unsafe { &mut *system_table };
-    let bs = unsafe { &mut *st.boot_services };
-    let con_out = unsafe { &mut *st.con_out };
-
-    // ---- Phase 1: UEFI boot services alive ----
-
-    // Print banner via UEFI console
-    unsafe {
-        let banner: [u16; 28] = [
-            'r' as u16, 'a' as u16, 'i' as u16, 's' as u16, 'e' as u16, 'r' as u16, 'n' as u16,
-            'i' as u16, 'c' as u16, 's' as u16, ' ' as u16, 'v' as u16, '0' as u16, '.' as u16,
-            '1' as u16, ' ' as u16, '-' as u16, ' ' as u16, 'b' as u16, 'o' as u16, 'o' as u16,
-            't' as u16, 'i' as u16, 'n' as u16, 'g' as u16, '.' as u16, '.' as u16, 0x0A,
-        ];
-        (con_out.output_string)(con_out, banner.as_ptr());
-    }
-
-    // Init serial early so we can debug-print before EBS
-    serial::init();
-
-    serial_println!("=== raisernics boot ===");
-
-    // Stash the memory map
-    let map_key = memory::capture_memory_map(bs);
-    let map_key = match map_key {
-        Ok(k) => k,
-        Err(e) => {
-            serial_println!("mem: capture_memory_map failed 0x{:x}", e);
-            0
-        }
-    };
-
-    // Locate GOP (Graphics Output Protocol)
-    let mut gop_interface: *mut core::ffi::c_void = core::ptr::null_mut();
-    let gop_guid = EFI_GRAPHICS_OUTPUT_PROTOCOL_GUID;
-    let gop_result = unsafe {
-        (bs.locate_protocol)(
-            &gop_guid as *const Guid,
-            core::ptr::null_mut(),
-            &mut gop_interface,
-        )
-    };
-    if gop_result == EFI_SUCCESS {
-        let gop = unsafe { &mut *(gop_interface as *mut GraphicsOutputProtocol) };
-        serial_println!("gop: framebuffer found");
-        gop::init(gop);
-    } else {
-        serial_println!("gop: not found (0x{:x})", gop_result);
-    }
-
-    // ExitBootServices — we now own the machine
-    let ebs_result = unsafe { (bs.exit_boot_services)(image_handle, map_key) };
-    if ebs_result != EFI_SUCCESS {
-        // Memory map may have changed; try again with fresh map
-        // (This is the standard UEFI EBS retry dance.)
-        serial_println!(
-            "WARN: ExitBootServices failed (0x{:x}), retrying...",
-            ebs_result
-        );
-        let _map_key = match memory::refresh_and_exit(bs, image_handle) {
-            Ok(k) => k,
-            Err(e) => {
-                serial_println!("FATAL: cannot ExitBootServices (0x{:x})", e);
-                loop {
-                    unsafe {
-                        core::arch::asm!("cli; hlt");
-                    }
-                }
-            }
-        };
-    }
-
-    // ---- Phase 2: Native mode ----
-
-    serial::init();
-    serial_println!("serial: COM1 115200 8N1");
-
-    // PS/2 keyboard
-    ps2::init();
-    serial_println!("ps2: keyboard initialized");
-
-    // Interrupts — IDT, PIC, PIT timer, keyboard IRQ handler
-    interrupts::init();
-    serial_println!("intr: IDT loaded, PIC remapped, timer ~100 Hz");
-
-    // Memory: the bump allocator was set up during capture_memory_map.
-    // `alloc::Vec`, `alloc::String`, `format!` etc. are now usable.
-
-    // Print memory summary
-    dump_memory_summary();
-
-    serial_println!("boot: entering shell");
-    shell::run();
-}
-
-// ---------------------------------------------------------------------------
-// Print a memory summary from the stashed memory map
-// ---------------------------------------------------------------------------
-fn dump_memory_summary() {
-    let (map, key) = memory::get_map();
-    let mut conventional_4k = 0u64;
-    let mut addr_space_4k = 0u64;
-    for desc in map.iter() {
-        let pages = desc.number_of_pages;
-        addr_space_4k += pages;
-        if desc.kind == 7 {
-            conventional_4k += pages;
-        }
-    }
-    serial_println!(
-        "mem: {} entries, key=0x{:x}, usable: {} KB ({} MB)",
-        map.len(),
-        key,
-        conventional_4k * 4,
-        (conventional_4k * 4) / 1024,
-    );
-    serial_println!(
-        "mem: address space: {} MB (incl. PCIe MMIO)",
-        (addr_space_4k * 4) / 1024,
-    );
-}
-
-// ---------------------------------------------------------------------------
-// Helper: write a panic-proof string via UEFI console (used before serial)
-// ---------------------------------------------------------------------------
-#[allow(dead_code)]
-unsafe fn uefi_puts(con_out: *mut SimpleTextOutput, s: &str) {
-    // Simple ASCII → UEFI-CHAR16 conversion (stack buffer, panic-safe)
-    let mut buf: [u16; 128] = [0; 128];
-    let len = s.len().min(127);
-    for (i, &b) in s.as_bytes()[..len].iter().enumerate() {
-        buf[i] = b as u16;
-    }
-    buf[len] = 0x0A; // LF
-    let out = unsafe { &mut *con_out };
-    (out.output_string)(out, buf.as_ptr());
-}