Merge pull request #206 from ryanbreen/feat/block-io-confetti-pointer

feat: block I/O fix, confetti demo, and mouse pointer support

Author: ryanbreen

kernel/src/arch_impl/aarch64/syscall_entry.rs

@@ -6,6 +6,14 @@
 use super::mmio::{VirtioMmioDevice, device_id, VIRTIO_MMIO_BASE, VIRTIO_MMIO_SIZE, VIRTIO_MMIO_COUNT};
 use core::ptr::read_volatile;
 use core::sync::atomic::{fence, Ordering};
+use spin::Mutex;
+
+/// Lock protecting all shared DMA buffers (REQ_HEADER, DATA_BUF, STATUS_BUF, QUEUE_MEM).
+///
+/// The x86_64 PCI block driver uses Mutex<Virtqueue> for the same purpose (block.rs:81).
+/// Without this lock, concurrent exec() calls (e.g., init spawning telnetd + bsh) corrupt
+/// each other's request headers mid-flight, causing ELF load failures.
+static BLOCK_IO_LOCK: Mutex<()> = Mutex::new(());
 
 // Import dsb_sy from the shared CPU module to avoid duplication
 use crate::arch_impl::aarch64::cpu::dsb_sy;
@@ -267,8 +275,36 @@ fn init_device(device: &mut VirtioMmioDevice, base: u64) -> Result<(), &'static
     Ok(())
 }
 
-/// Read a sector from the block device
+/// Read a sector from the block device.
+///
+/// Serializes access with BLOCK_IO_LOCK to prevent concurrent DMA buffer corruption.
+/// Disables interrupts before acquiring the lock to prevent same-core deadlock
+/// (matches the pattern in `kernel/src/process/mod.rs:85-88`).
 pub fn read_sector(sector: u64, buffer: &mut [u8; SECTOR_SIZE]) -> Result<(), &'static str> {
+    // Save DAIF and disable interrupts to prevent same-core deadlock:
+    // if a timer interrupt preempts while we hold the spinlock, the scheduler
+    // could switch to another thread on this core that tries to acquire the
+    // same lock, spinning forever.
+    let saved_daif: u64;
+    unsafe {
+        core::arch::asm!("mrs {}, daif", out(reg) saved_daif, options(nomem, nostack));
+        core::arch::asm!("msr daifset, #0xf", options(nomem, nostack));
+    }
+
+    let _guard = BLOCK_IO_LOCK.lock();
+    let result = read_sector_inner(sector, buffer);
+    drop(_guard);
+
+    // Restore interrupt state
+    unsafe {
+        core::arch::asm!("msr daif, {}", in(reg) saved_daif, options(nomem, nostack));
+    }
+
+    result
+}
+
+/// Inner implementation of read_sector, called with BLOCK_IO_LOCK held.
+fn read_sector_inner(sector: u64, buffer: &mut [u8; SECTOR_SIZE]) -> Result<(), &'static str> {
     // Use raw pointers to avoid references to mutable statics
     let state = unsafe {
         let ptr = &raw mut BLOCK_DEVICE;
@@ -390,8 +426,29 @@ pub fn read_sector(sector: u64, buffer: &mut [u8; SECTOR_SIZE]) -> Result<(), &'
     Ok(())
 }
 
-/// Write a sector to the block device
+/// Write a sector to the block device.
+///
+/// Serializes access with BLOCK_IO_LOCK (same as read_sector).
 pub fn write_sector(sector: u64, buffer: &[u8; SECTOR_SIZE]) -> Result<(), &'static str> {
+    let saved_daif: u64;
+    unsafe {
+        core::arch::asm!("mrs {}, daif", out(reg) saved_daif, options(nomem, nostack));
+        core::arch::asm!("msr daifset, #0xf", options(nomem, nostack));
+    }
+
+    let _guard = BLOCK_IO_LOCK.lock();
+    let result = write_sector_inner(sector, buffer);
+    drop(_guard);
+
+    unsafe {
+        core::arch::asm!("msr daif, {}", in(reg) saved_daif, options(nomem, nostack));
+    }
+
+    result
+}
+
+/// Inner implementation of write_sector, called with BLOCK_IO_LOCK held.
+fn write_sector_inner(sector: u64, buffer: &[u8; SECTOR_SIZE]) -> Result<(), &'static str> {
     // Use raw pointers to avoid references to mutable statics
     let state = unsafe {
         let ptr = &raw mut BLOCK_DEVICE;

kernel/src/drivers/virtio/block_mmio.rs

@@ -8,6 +8,7 @@ use super::primitives::{draw_text, fill_rect, Canvas, Color, Rect, TextStyle};
 use super::terminal::TerminalPane;
 use alloc::collections::VecDeque;
 use alloc::string::String;
+use alloc::vec::Vec;
 use spin::Mutex;
 
 // Architecture-specific framebuffer imports
@@ -103,6 +104,10 @@ pub struct TerminalManager {
     has_unread: [bool; 2],
     /// Scroll offset for Logs tab (0 = following tail, >0 = scrolled up)
     logs_scroll_offset: usize,
+    /// Saved pixel data for the shell terminal area (saved when switching away)
+    shell_pixel_backup: Option<Vec<u8>>,
+    /// Saved cursor position for the shell terminal (col, row)
+    shell_cursor_backup: (usize, usize),
 }
 
 impl TerminalManager {
@@ -136,6 +141,8 @@ impl TerminalManager {
             tab_shortcuts: ["F1", "F2"],
             has_unread: [false, false],
             logs_scroll_offset: 0,
+            shell_pixel_backup: None,
+            shell_cursor_backup: (0, 0),
         }
     }
 
@@ -155,6 +162,12 @@ impl TerminalManager {
         // Hide cursor
         self.terminal_pane.draw_cursor(canvas, false);
 
+        // If leaving the Shell tab, save its pixel content and cursor position
+        if self.active_idx == TerminalId::Shell as usize {
+            self.shell_cursor_backup = self.terminal_pane.cursor();
+            self.shell_pixel_backup = Some(self.save_terminal_pixels(canvas));
+        }
+
         self.active_idx = new_idx;
         self.has_unread[new_idx] = false;
 
@@ -165,8 +178,12 @@ impl TerminalManager {
         // Restore content for the new active terminal
         match id {
             TerminalId::Shell => {
-                // Shell: just show prompt (shell will redraw its state)
-                self.terminal_pane.write_str(canvas, "breenix> ");
+                // Restore the saved shell pixel content
+                if let Some(ref saved) = self.shell_pixel_backup {
+                    self.restore_terminal_pixels(canvas, saved);
+                }
+                let (col, row) = self.shell_cursor_backup;
+                self.terminal_pane.set_cursor(col, row);
             }
             TerminalId::Logs => {
                 // Reset scroll to follow tail when switching to Logs
@@ -198,6 +215,46 @@ impl TerminalManager {
         self.terminal_pane.set_cursor(0, 0);
     }
 
+    /// Save the terminal content area pixels to a Vec.
+    fn save_terminal_pixels(&self, canvas: &impl Canvas) -> Vec<u8> {
+        let pane_y = self.region_y + TAB_HEIGHT + 2;
+        let pane_height = self.region_height.saturating_sub(TAB_HEIGHT + 2);
+        let bpp = canvas.bytes_per_pixel();
+        let stride = canvas.stride();
+        let buffer = canvas.buffer();
+        let row_bytes = self.region_width * bpp;
+
+        let mut saved = Vec::with_capacity(row_bytes * pane_height);
+        for row in 0..pane_height {
+            let offset = (pane_y + row) * stride * bpp + self.region_x * bpp;
+            if offset + row_bytes <= buffer.len() {
+                saved.extend_from_slice(&buffer[offset..offset + row_bytes]);
+            }
+        }
+        saved
+    }
+
+    /// Restore previously saved terminal content area pixels.
+    fn restore_terminal_pixels(&self, canvas: &mut impl Canvas, saved: &[u8]) {
+        let pane_y = self.region_y + TAB_HEIGHT + 2;
+        let pane_height = self.region_height.saturating_sub(TAB_HEIGHT + 2);
+        let bpp = canvas.bytes_per_pixel();
+        let stride = canvas.stride();
+        let row_bytes = self.region_width * bpp;
+
+        let buffer = canvas.buffer_mut();
+        let mut src_offset = 0;
+        for row in 0..pane_height {
+            let dst_offset = (pane_y + row) * stride * bpp + self.region_x * bpp;
+            if dst_offset + row_bytes <= buffer.len() && src_offset + row_bytes <= saved.len() {
+                buffer[dst_offset..dst_offset + row_bytes]
+                    .copy_from_slice(&saved[src_offset..src_offset + row_bytes]);
+            }
+            src_offset += row_bytes;
+        }
+        canvas.mark_dirty_region(self.region_x, pane_y, self.region_width, pane_height);
+    }
+
     /// Initialize the terminal manager.
     pub fn init(&mut self, canvas: &mut impl Canvas) {
         // Clear entire region

kernel/src/graphics/terminal_manager.rs

@@ -119,6 +119,7 @@ pub fn dispatch_syscall(
         SyscallNumber::FbInfo => super::graphics::sys_fbinfo(arg1),
         SyscallNumber::FbDraw => super::graphics::sys_fbdraw(arg1),
         SyscallNumber::FbMmap => super::graphics::sys_fbmmap(),
+        SyscallNumber::GetMousePos => super::graphics::sys_get_mouse_pos(arg1),
         // Testing/diagnostic syscalls (Breenix-specific)
         SyscallNumber::CowStats => super::handlers::sys_cow_stats(arg1),
         SyscallNumber::SimulateOom => super::handlers::sys_simulate_oom(arg1),

kernel/src/syscall/dispatcher.rs

@@ -448,6 +448,41 @@ pub fn sys_fbdraw(_cmd_ptr: u64) -> SyscallResult {
     SyscallResult::Err(super::ErrorCode::InvalidArgument as u64)
 }
 
+/// sys_get_mouse_pos - Get current mouse cursor position
+///
+/// # Arguments
+/// * `out_ptr` - Pointer to a [u32; 2] array in userspace: [x, y]
+///
+/// # Returns
+/// * 0 on success
+/// * -EFAULT if out_ptr is invalid
+#[cfg(target_arch = "aarch64")]
+pub fn sys_get_mouse_pos(out_ptr: u64) -> SyscallResult {
+    if out_ptr == 0 || out_ptr >= USER_SPACE_MAX {
+        return SyscallResult::Err(super::ErrorCode::Fault as u64);
+    }
+
+    let end_ptr = out_ptr.saturating_add(8); // 2 * u32
+    if end_ptr > USER_SPACE_MAX {
+        return SyscallResult::Err(super::ErrorCode::Fault as u64);
+    }
+
+    let (mx, my) = crate::drivers::virtio::input_mmio::mouse_position();
+
+    unsafe {
+        let out = out_ptr as *mut [u32; 2];
+        core::ptr::write(out, [mx, my]);
+    }
+
+    SyscallResult::Ok(0)
+}
+
+/// sys_get_mouse_pos - Stub for non-aarch64
+#[cfg(not(target_arch = "aarch64"))]
+pub fn sys_get_mouse_pos(_out_ptr: u64) -> SyscallResult {
+    SyscallResult::Err(super::ErrorCode::InvalidArgument as u64)
+}
+
 /// sys_fbmmap - Map a framebuffer buffer into the calling process's address space
 ///
 /// Allocates physical frames, maps them into the process as a compact left-pane

kernel/src/syscall/graphics.rs

@@ -141,6 +141,7 @@ pub enum SyscallNumber {
     FbInfo = 410,       // Breenix: get framebuffer info
     FbDraw = 411,       // Breenix: draw to framebuffer (left pane)
     FbMmap = 412,       // Breenix: mmap framebuffer into userspace
+    GetMousePos = 413,  // Breenix: get mouse cursor position
     CowStats = 500,     // Breenix: get Copy-on-Write statistics (for testing)
     SimulateOom = 501,  // Breenix: enable/disable OOM simulation (for testing)
 }
@@ -234,6 +235,7 @@ impl SyscallNumber {
             410 => Some(Self::FbInfo),
             411 => Some(Self::FbDraw),
             412 => Some(Self::FbMmap),
+            413 => Some(Self::GetMousePos),
             500 => Some(Self::CowStats),
             501 => Some(Self::SimulateOom),
             _ => None,

kernel/src/syscall/mod.rs

@@ -238,6 +238,18 @@ pub fn fb_flush_rect(x: i32, y: i32, w: i32, h: i32) -> Result<(), Error> {
     fbdraw(&cmd)
 }
 
+/// Get the current mouse cursor position.
+///
+/// # Returns
+/// * Ok((x, y)) - Mouse position in screen coordinates
+/// * Err(Error) - Error (ENODEV if no pointer device)
+pub fn mouse_pos() -> Result<(u32, u32), Error> {
+    let mut pos: [u32; 2] = [0, 0];
+    let ret = unsafe { raw::syscall1(nr::GET_MOUSE_POS, &mut pos as *mut [u32; 2] as u64) as i64 };
+    Error::from_syscall(ret)?;
+    Ok((pos[0], pos[1]))
+}
+
 // ============================================================================
 // RAII Framebuffer Wrapper
 // ============================================================================

libs/libbreenix/src/graphics.rs

@@ -91,6 +91,7 @@ pub mod nr {
     pub const FBINFO: u64 = 410;       // Breenix: get framebuffer info
     pub const FBDRAW: u64 = 411;       // Breenix: draw to framebuffer
     pub const FBMMAP: u64 = 412;       // Breenix: mmap framebuffer into userspace
+    pub const GET_MOUSE_POS: u64 = 413; // Breenix: get mouse cursor position
     pub const CLONE: u64 = 56;           // Linux x86_64 clone
     pub const FUTEX: u64 = 202;          // Linux x86_64 futex
     pub const GETRANDOM: u64 = 318;    // Linux x86_64 getrandom

libs/libbreenix/src/syscall.rs

@@ -506,6 +506,10 @@ path = "src/wc_test.rs"
 name = "which_test"
 path = "src/which_test.rs"
 
+[[bin]]
+name = "confetti"
+path = "src/confetti.rs"
+
 [[bin]]
 name = "bsh"
 path = "src/bsh.rs"

userspace/programs/Cargo.toml

@@ -211,6 +211,7 @@ STD_BINARIES=(
     "demo"
     "bounce"
     "particles"
+    "confetti"
     "http_test"
     "register_init_test"