Merge pull request #252 from ryanbreen/feat/compositor-perf

feat: MAP_SHARED compositor, cursor fix, mouse encoding fix

Author: ryanbreen

kernel/src/drivers/usb/hid.rs

@@ -176,9 +176,13 @@ pub fn process_keyboard_report(report: &[u8]) {
     let keys = &report[2..8];
 
     // Update modifier state from the modifier byte
-    // Bit 0: Left Ctrl,  Bit 1: Left Shift,  Bit 4: Right Ctrl, Bit 5: Right Shift
+    // Bit 0: Left Ctrl,  Bit 1: Left Shift,  Bit 2: Left Alt
+    // Bit 3: Left GUI,   Bit 4: Right Ctrl,  Bit 5: Right Shift
+    // Bit 6: Right Alt,  Bit 7: Right GUI
+    // Map GUI (Command on macOS) to ctrl so Command+T/W/C work in terminal
     let shift = (modifiers & 0x02) != 0 || (modifiers & 0x20) != 0;
-    let ctrl = (modifiers & 0x01) != 0 || (modifiers & 0x10) != 0;
+    let ctrl = (modifiers & 0x01) != 0 || (modifiers & 0x10) != 0
+             || (modifiers & 0x08) != 0 || (modifiers & 0x80) != 0;
     SHIFT_PRESSED.store(shift, Ordering::Relaxed);
     CTRL_PRESSED.store(ctrl, Ordering::Relaxed);
 

kernel/src/drivers/virtio/gpu_pci.rs

@@ -731,6 +731,7 @@ fn generate_stat() -> String {
     use crate::tracing::providers::counters::{
         SYSCALL_TOTAL, IRQ_TOTAL, CTX_SWITCH_TOTAL, TIMER_TICK_TOTAL,
         FORK_TOTAL, EXEC_TOTAL, COW_FAULT_TOTAL,
+        GPU_BYTES_UPLOADED, GPU_FULL_UPLOADS, GPU_PARTIAL_UPLOADS,
     };
 
     format!(
@@ -740,14 +741,20 @@ fn generate_stat() -> String {
          timer_ticks {}\n\
          forks {}\n\
          execs {}\n\
-         cow_faults {}\n",
+         cow_faults {}\n\
+         gpu_bytes {}\n\
+         gpu_full {}\n\
+         gpu_partial {}\n",
         SYSCALL_TOTAL.aggregate(),
         IRQ_TOTAL.aggregate(),
         CTX_SWITCH_TOTAL.aggregate(),
         TIMER_TICK_TOTAL.aggregate(),
         FORK_TOTAL.aggregate(),
         EXEC_TOTAL.aggregate(),
         COW_FAULT_TOTAL.aggregate(),
+        GPU_BYTES_UPLOADED.aggregate(),
+        GPU_FULL_UPLOADS.aggregate(),
+        GPU_PARTIAL_UPLOADS.aggregate(),
     )
 }
 

kernel/src/fs/procfs/mod.rs

@@ -965,6 +965,20 @@ fn handle_virgl_op(cmd: &FbDrawCmd) -> SyscallResult {
 
             SyscallResult::Ok(count as u64)
         }
+        20 => {
+            // MapCompositorTexture: map COMPOSITE_TEX backing pages into caller's
+            // address space for zero-copy compositor writes.
+            // p1/p2 = output pointer (lo/hi) for mapped address (u64)
+            // Returns: packed (width << 32 | height) on success.
+            #[cfg(target_arch = "aarch64")]
+            {
+                handle_map_compositor_texture(cmd)
+            }
+            #[cfg(not(target_arch = "aarch64"))]
+            {
+                SyscallResult::Err(super::ErrorCode::InvalidArgument as u64)
+            }
+        }
         _ => {
             crate::serial_println!("[virgl-op] UNKNOWN op={}", cmd.op);
             SyscallResult::Err(super::ErrorCode::InvalidArgument as u64)
@@ -973,14 +987,23 @@ fn handle_virgl_op(cmd: &FbDrawCmd) -> SyscallResult {
 }
 
 /// Descriptor for multi-window GPU compositing (passed from userspace).
+///
+/// bg_dirty modes:
+///   0 = no background change (cursor/frame-pacing only)
+///   1 = full background upload (entire buffer changed)
+///   2 = partial background upload (only dirty_rect region changed)
 #[cfg(target_arch = "aarch64")]
 #[repr(C)]
 struct CompositeWindowsDesc {
     bg_pixels_ptr: u64,
     bg_width: u32,
     bg_height: u32,
     bg_dirty: u32,
-    _reserved: u32,
+    num_dirty_rects: u32,
+    dirty_x: u32,
+    dirty_y: u32,
+    dirty_w: u32,
+    dirty_h: u32,
 }
 
 /// Handle multi-window GPU compositing (op=16).
@@ -991,11 +1014,27 @@ struct CompositeWindowsDesc {
 fn handle_composite_windows(desc_ptr: u64) -> SyscallResult {
     let desc: CompositeWindowsDesc = unsafe { core::ptr::read(desc_ptr as *const CompositeWindowsDesc) };
 
-    if desc.bg_width == 0 || desc.bg_height == 0 || desc.bg_width > 4096 || desc.bg_height > 4096 {
-        return SyscallResult::Err(super::ErrorCode::InvalidArgument as u64);
-    }
+    // When bg_pixels_ptr=0 (direct-mapped compositor), use COMPOSITE_TEX dimensions
+    let (bg_width, bg_height) = if desc.bg_pixels_ptr == 0 {
+        match crate::drivers::virtio::gpu_pci::compositor_texture_info() {
+            Some((_phys, _pages, w, h)) => (w, h),
+            None => return SyscallResult::Err(super::ErrorCode::InvalidArgument as u64),
+        }
+    } else {
+        if desc.bg_width == 0 || desc.bg_height == 0 || desc.bg_width > 4096 || desc.bg_height > 4096 {
+            return SyscallResult::Err(super::ErrorCode::InvalidArgument as u64);
+        }
+        (desc.bg_width, desc.bg_height)
+    };
 
     let bg_dirty = desc.bg_dirty != 0;
+    let dirty_rect = if desc.bg_dirty == 2 && desc.num_dirty_rects > 0
+        && desc.dirty_w > 0 && desc.dirty_h > 0
+    {
+        Some((desc.dirty_x, desc.dirty_y, desc.dirty_w, desc.dirty_h))
+    } else {
+        None
+    };
 
     // Fast path: quick dirty check under lock — no heap allocs if nothing changed
     if !bg_dirty {
@@ -1058,7 +1097,7 @@ fn handle_composite_windows(desc_ptr: u64) -> SyscallResult {
     }
 
     let bg_pixels = if desc.bg_pixels_ptr != 0 && desc.bg_pixels_ptr < USER_SPACE_MAX {
-        let pixel_count = (desc.bg_width as usize) * (desc.bg_height as usize);
+        let pixel_count = (bg_width as usize) * (bg_height as usize);
         let end = desc.bg_pixels_ptr + (pixel_count as u64) * 4;
         if end > USER_SPACE_MAX {
             return SyscallResult::Err(super::ErrorCode::Fault as u64);
@@ -1108,7 +1147,7 @@ fn handle_composite_windows(desc_ptr: u64) -> SyscallResult {
     };
 
     let result = match crate::drivers::virtio::gpu_pci::virgl_composite_windows(
-        bg_pixels, desc.bg_width, desc.bg_height, bg_dirty, None, &windows,
+        bg_pixels, bg_width, bg_height, bg_dirty, dirty_rect, &windows,
     ) {
         Ok(()) => SyscallResult::Ok(0),
         Err(e) => {
@@ -1279,6 +1318,99 @@ fn handle_create_window_buffer(width: u32, height: u32, out_addr_ptr: u64) -> Sy
     SyscallResult::Ok(buffer_id as u64)
 }
 
+/// Handle map_compositor_texture: map COMPOSITE_TEX backing pages into the
+/// calling process's address space (read/write). This allows BWM to write
+/// pixels directly into the GPU texture backing, eliminating the kernel-side
+/// copy in virgl_composite_windows Phase A.
+#[cfg(target_arch = "aarch64")]
+fn handle_map_compositor_texture(cmd: &FbDrawCmd) -> SyscallResult {
+    use crate::memory::vma::{MmapFlags, Protection, Vma};
+    use crate::syscall::memory_common::{
+        get_current_thread_id, prot_to_page_flags, flush_tlb, round_down_to_page, PAGE_SIZE,
+    };
+    use crate::memory::arch_stub::{Page, Size4KiB, VirtAddr};
+
+    let out_ptr = (cmd.p1 as u32 as u64) | ((cmd.p2 as u32 as u64) << 32);
+    if out_ptr == 0 || out_ptr >= USER_SPACE_MAX {
+        return SyscallResult::Err(super::ErrorCode::Fault as u64);
+    }
+
+    // Get compositor texture info from GPU driver
+    let (phys_base, num_pages, tex_w, tex_h) =
+        match crate::drivers::virtio::gpu_pci::compositor_texture_info() {
+            Some(info) => info,
+            None => return SyscallResult::Err(super::ErrorCode::InvalidArgument as u64),
+        };
+
+    // Get current process
+    let current_thread_id = match get_current_thread_id() {
+        Some(id) => id,
+        None => return SyscallResult::Err(super::ErrorCode::NoSuchProcess as u64),
+    };
+
+    let mut manager_guard = crate::process::manager();
+    let manager = match *manager_guard {
+        Some(ref mut m) => m,
+        None => return SyscallResult::Err(super::ErrorCode::NoSuchProcess as u64),
+    };
+
+    let (_pid, process) = match manager.find_process_by_thread_mut(current_thread_id) {
+        Some(p) => p,
+        None => return SyscallResult::Err(super::ErrorCode::NoSuchProcess as u64),
+    };
+
+    // Allocate virtual address range from mmap hint
+    let total_size = (num_pages as u64) * PAGE_SIZE;
+    let new_addr = round_down_to_page(process.mmap_hint.saturating_sub(total_size));
+    if new_addr < 0x1000_0000 {
+        return SyscallResult::Err(super::ErrorCode::OutOfMemory as u64);
+    }
+    process.mmap_hint = new_addr;
+
+    let page_table = match process.page_table.as_mut() {
+        Some(pt) => pt,
+        None => return SyscallResult::Err(super::ErrorCode::OutOfMemory as u64),
+    };
+
+    // Map each physical page of COMPOSITE_TEX into the process
+    let page_flags = prot_to_page_flags(Protection::from_bits_truncate(3)); // READ | WRITE
+    for i in 0..num_pages as usize {
+        let frame_phys = phys_base + (i as u64) * PAGE_SIZE;
+        let frame = crate::memory::arch_stub::PhysFrame::<Size4KiB>::containing_address(
+            crate::memory::arch_stub::PhysAddr::new(frame_phys),
+        );
+        let page_addr = new_addr + (i as u64) * PAGE_SIZE;
+        let page = Page::<Size4KiB>::containing_address(VirtAddr::new(page_addr));
+
+        if let Err(_) = page_table.map_page(page, frame, page_flags) {
+            return SyscallResult::Err(super::ErrorCode::OutOfMemory as u64);
+        }
+        flush_tlb(VirtAddr::new(page_addr));
+    }
+
+    // Create VMA
+    let vma = Vma::new(
+        VirtAddr::new(new_addr),
+        VirtAddr::new(new_addr + total_size),
+        Protection::from_bits_truncate(3),
+        MmapFlags::from_bits_truncate(0x21), // MAP_SHARED | MAP_ANONYMOUS
+    );
+    process.vmas.push(vma);
+
+    crate::serial_println!(
+        "[compositor] Mapped COMPOSITE_TEX into process: virt={:#x}, {}x{}, {} pages",
+        new_addr, tex_w, tex_h, num_pages
+    );
+
+    // Write mapped address to userspace
+    unsafe {
+        core::ptr::write(out_ptr as *mut u64, new_addr);
+    }
+
+    // Return packed dimensions
+    SyscallResult::Ok(((tex_w as u64) << 32) | tex_h as u64)
+}
+
 /// sys_fbdraw - Draw to the left pane of the framebuffer
 ///
 /// # Arguments

kernel/src/syscall/graphics.rs

@@ -123,6 +123,27 @@ pub static COW_FAULT_TOTAL: TraceCounter = TraceCounter::new(
     "Total CoW fault operations",
 );
 
+/// GPU compositor: total bytes uploaded to VRAM.
+#[no_mangle]
+pub static GPU_BYTES_UPLOADED: TraceCounter = TraceCounter::new(
+    "GPU_BYTES_UPLOADED",
+    "GPU bytes uploaded to VRAM",
+);
+
+/// GPU compositor: full-screen uploads (4.9MB each).
+#[no_mangle]
+pub static GPU_FULL_UPLOADS: TraceCounter = TraceCounter::new(
+    "GPU_FULL_UPLOADS",
+    "Full-screen GPU uploads",
+);
+
+/// GPU compositor: partial rect uploads.
+#[no_mangle]
+pub static GPU_PARTIAL_UPLOADS: TraceCounter = TraceCounter::new(
+    "GPU_PARTIAL_UPLOADS",
+    "Partial rect GPU uploads",
+);
+
 // =============================================================================
 // Boot Test Counters (BTRT feature)
 // =============================================================================
@@ -182,6 +203,9 @@ pub fn init() {
     register_counter(&FORK_TOTAL);
     register_counter(&EXEC_TOTAL);
     register_counter(&COW_FAULT_TOTAL);
+    register_counter(&GPU_BYTES_UPLOADED);
+    register_counter(&GPU_FULL_UPLOADS);
+    register_counter(&GPU_PARTIAL_UPLOADS);
 
     #[cfg(feature = "btrt")]
     {

kernel/src/tracing/providers/counters.rs

@@ -59,9 +59,9 @@ impl Event {
             },
             input_event_type::MOUSE_BUTTON => Event::MouseButton {
                 button: raw.keycode as u8,
-                pressed: raw.mouse_x != 0,
-                x: raw.mouse_y as i32,
-                y: 0,
+                pressed: raw._pad != 0,
+                x: raw.mouse_x as i32,
+                y: raw.mouse_y as i32,
             },
             input_event_type::FOCUS_GAINED => Event::FocusGained,
             input_event_type::FOCUS_LOST => Event::FocusLost,

libs/breengel/src/event.rs

@@ -130,6 +130,8 @@ pub mod draw_op {
     pub const WRITE_WINDOW_INPUT: u32 = 18;
     /// Read input events from a window's ring buffer (client ← BWM)
     pub const READ_WINDOW_INPUT: u32 = 19;
+    /// Map compositor texture into caller's address space
+    pub const MAP_COMPOSITOR_TEXTURE: u32 = 20;
 }
 
 /// Ball descriptor for VirGL GPU rendering.
@@ -683,7 +685,7 @@ pub fn virgl_composite_windows_rect(
     dirty_mode: u32, dirty_x: u32, dirty_y: u32, dirty_w: u32, dirty_h: u32,
 ) -> Result<(), Error> {
     let desc = CompositeWindowsDesc {
-        bg_pixels_ptr: bg_pixels.as_ptr() as u64,
+        bg_pixels_ptr: if bg_pixels.is_empty() { 0 } else { bg_pixels.as_ptr() as u64 },
         bg_width: bg_w,
         bg_height: bg_h,
         bg_dirty: dirty_mode,
@@ -705,6 +707,36 @@ pub fn virgl_composite_windows_rect(
     fbdraw(&cmd)
 }
 
+/// Map the compositor texture backing into this process's address space.
+///
+/// Returns a pointer to the mapped memory along with the texture dimensions.
+/// BWM can write pixels directly into this memory — they are the GPU texture
+/// backing pages. This eliminates the kernel-side copy in the composite syscall.
+///
+/// # Returns
+/// * Ok((ptr, width, height)) - Mapped pointer + dimensions
+/// * Err(Error) - Error if compositor texture is not initialized
+pub fn map_compositor_texture() -> Result<(*mut u32, u32, u32), Error> {
+    let mut mapped_addr: u64 = 0;
+    let out_ptr = &mut mapped_addr as *mut u64 as u64;
+    let cmd = FbDrawCmd {
+        op: draw_op::MAP_COMPOSITOR_TEXTURE,
+        p1: out_ptr as i32,
+        p2: (out_ptr >> 32) as i32,
+        p3: 0,
+        p4: 0,
+        color: 0,
+    };
+    let ret = unsafe { raw::syscall1(nr::FBDRAW, &cmd as *const FbDrawCmd as u64) as i64 };
+    if ret < 0 {
+        return Err(Error::Os(Errno::from_raw(-ret)));
+    }
+    let result = ret as u64;
+    let width = (result >> 32) as u32;
+    let height = (result & 0xFFFF_FFFF) as u32;
+    Ok((mapped_addr as *mut u32, width, height))
+}
+
 /// Get the current mouse cursor position.
 ///
 /// # Returns