Merge pull request #245 from ryanbreen/feat/gpu-window-manager

GPU-composited tiling window manager with VirGL textured quads

Author: ryanbreen

kernel/src/drivers/virtio/gpu_pci.rs

@@ -520,25 +520,34 @@ impl CommandBuffer {
     /// Create a sampler view (binds a texture resource for shader sampling).
     ///
     /// VirGL protocol: CREATE_OBJECT(SAMPLER_VIEW) with 6 payload DWORDs:
-    /// `[handle, res_handle, format, first_level, last_level, swizzle_packed]`
+    /// `[handle, res_handle, fmt_target, val0(layers), val1(levels), swizzle_packed]`
     ///
+    /// `fmt_target`: bits [0:23] = pipe format, bits [24:31] = pipe texture target.
+    /// `val0`: `first_layer | (last_layer << 16)` (for TEXTURE_2D, both 0).
+    /// `val1`: `first_level | (last_level << 8)` (for single-mip, both 0).
     /// `swizzle_packed` encodes channel mapping: `r | (g<<3) | (b<<6) | (a<<9)`
     /// using constants from `swizzle::*`. Use `swizzle::IDENTITY` for default.
     pub fn create_sampler_view(
         &mut self,
         handle: u32,
         res_handle: u32,
         format: u32,
+        target: u32,
+        first_layer: u32,
+        last_layer: u32,
         first_level: u32,
         last_level: u32,
         swizzle_packed: u32,
     ) {
+        let fmt_target = (format & 0x00FF_FFFF) | ((target & 0xFF) << 24);
+        let val0 = (first_layer & 0xFFFF) | ((last_layer & 0xFFFF) << 16);
+        let val1 = (first_level & 0xFF) | ((last_level & 0xFF) << 8);
         self.push(Self::cmd0(ccmd::CREATE_OBJECT, obj::SAMPLER_VIEW, 6));
         self.push(handle);
         self.push(res_handle);
-        self.push(format);
-        self.push(first_level);
-        self.push(last_level);
+        self.push(fmt_target);
+        self.push(val0);
+        self.push(val1);
         self.push(swizzle_packed);
     }
 

kernel/src/drivers/virtio/virgl.rs

@@ -455,24 +455,31 @@ fn handle_virgl_op(cmd: &FbDrawCmd) -> SyscallResult {
             let pixels = unsafe {
                 core::slice::from_raw_parts(buf_ptr as *const u32, pixel_count as usize)
             };
-            match crate::drivers::virtio::gpu_pci::virgl_composite_frame(pixels, width, height) {
+            // Try GPU-textured compositing first, fall back to direct blit
+            match crate::drivers::virtio::gpu_pci::virgl_composite_frame_textured(pixels, width, height) {
                 Ok(()) => SyscallResult::Ok(0),
-                Err(e) => {
-                    crate::serial_println!("[virgl-syscall] composite_frame FAILED: {}", e);
-                    SyscallResult::Err(super::ErrorCode::InvalidArgument as u64)
+                Err(_) => {
+                    match crate::drivers::virtio::gpu_pci::virgl_composite_frame(pixels, width, height) {
+                        Ok(()) => SyscallResult::Ok(0),
+                        Err(e) => {
+                            crate::serial_println!("[virgl-syscall] composite_frame FAILED: {}", e);
+                            SyscallResult::Err(super::ErrorCode::InvalidArgument as u64)
+                        }
+                    }
                 }
             }
         }
         11 => {
             // CreateWindowBuffer: allocate shared pixel buffer
-            // p1=width, p2=height
-            // Returns: buffer_id in OK value, userspace mmap addr in p1/p2 of output
+            // p1=width, p2=height, p3/p4 = output pointer (lo/hi) for mmap addr
+            // Returns: buffer_id in OK value, writes 64-bit mmap addr to *out_ptr
             let width = cmd.p1 as u32;
             let height = cmd.p2 as u32;
+            let out_ptr = (cmd.p3 as u32 as u64) | ((cmd.p4 as u32 as u64) << 32);
             if width == 0 || height == 0 || width > 4096 || height > 4096 {
                 return SyscallResult::Err(super::ErrorCode::InvalidArgument as u64);
             }
-            handle_create_window_buffer(width, height)
+            handle_create_window_buffer(width, height, out_ptr)
         }
         12 => {
             // RegisterWindow: register a buffer as a visible window
@@ -554,7 +561,10 @@ fn handle_virgl_op(cmd: &FbDrawCmd) -> SyscallResult {
                 None => SyscallResult::Err(super::ErrorCode::InvalidArgument as u64),
             }
         }
-        _ => SyscallResult::Err(super::ErrorCode::InvalidArgument as u64),
+        _ => {
+            crate::serial_println!("[virgl-op] UNKNOWN op={}", cmd.op);
+            SyscallResult::Err(super::ErrorCode::InvalidArgument as u64)
+        }
     }
 }
 
@@ -565,7 +575,7 @@ fn handle_virgl_op(cmd: &FbDrawCmd) -> SyscallResult {
 /// the process's mmap_hint, and the caller should use the window buffer API to
 /// get the mapped pointer).
 #[cfg(target_arch = "aarch64")]
-fn handle_create_window_buffer(width: u32, height: u32) -> SyscallResult {
+fn handle_create_window_buffer(width: u32, height: u32, out_addr_ptr: u64) -> 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,
@@ -580,22 +590,32 @@ fn handle_create_window_buffer(width: u32, height: u32) -> SyscallResult {
 
     let size = (width as usize) * (height as usize) * 4;
     let num_pages = (size + PAGE_SIZE as usize - 1) / PAGE_SIZE as usize;
+    crate::serial_println!("[window] create_window_buffer: {}x{} ({} bytes, {} pages)", width, height, size, num_pages);
 
     // Get current process
     let current_thread_id = match get_current_thread_id() {
         Some(id) => id,
-        None => return SyscallResult::Err(super::ErrorCode::NoSuchProcess as u64),
+        None => {
+            crate::serial_println!("[window] ERROR: get_current_thread_id returned 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),
+        None => {
+            crate::serial_println!("[window] ERROR: process manager not available");
+            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),
+        None => {
+            crate::serial_println!("[window] ERROR: thread {:?} not in process table", current_thread_id);
+            return SyscallResult::Err(super::ErrorCode::NoSuchProcess as u64);
+        }
     };
 
     // Allocate virtual address range from mmap hint
@@ -667,11 +687,15 @@ fn handle_create_window_buffer(width: u32, height: u32) -> SyscallResult {
         buffer_id, pid.as_u64(), width, height, new_addr, first_phys
     );
 
-    // Return buffer_id in upper 32 bits, mmap address in lower 32 bits
-    // (userspace can reconstruct: buffer_id = result >> 32, addr = result & 0xFFFFFFFF)
-    // Actually, return buffer_id and the address is the mmap_hint before allocation
-    // For simplicity, pack both: high 32 = buffer_id, low 32 = mmap addr page-aligned
-    SyscallResult::Ok(((buffer_id as u64) << 32) | (new_addr & 0xFFFF_FFFF))
+    // Write full 64-bit mmap address to userspace output pointer
+    if out_addr_ptr != 0 && out_addr_ptr < USER_SPACE_MAX {
+        unsafe {
+            core::ptr::write(out_addr_ptr as *mut u64, new_addr);
+        }
+    }
+
+    // Return just the buffer_id
+    SyscallResult::Ok(buffer_id as u64)
 }
 
 /// sys_fbdraw - Draw to the left pane of the framebuffer

kernel/src/syscall/graphics.rs

@@ -451,23 +451,21 @@ impl Default for WindowInfo {
 /// Returns a WindowBuffer with a mapped pixel pointer and buffer ID.
 /// The buffer can be registered with the compositor via `register_window()`.
 pub fn create_window(width: u32, height: u32) -> Result<WindowBuffer, Error> {
+    let mut mmap_addr: u64 = 0;
+    let out_ptr = &mut mmap_addr as *mut u64 as u64;
     let cmd = FbDrawCmd {
         op: draw_op::CREATE_WINDOW_BUFFER,
         p1: width as i32,
         p2: height as i32,
-        p3: 0,
-        p4: 0,
+        p3: out_ptr as i32,
+        p4: (out_ptr >> 32) as i32,
         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 buffer_id = (result >> 32) as u32;
-    let mmap_addr = (result & 0xFFFF_FFFF) as u64;
-    // On 64-bit, userspace mmap addresses may have upper bits from sign extension
-    // but the kernel returns the low 32 bits; reconstruct full address
+    let buffer_id = ret as u32;
     Ok(WindowBuffer {
         id: buffer_id,
         pixels: mmap_addr as *mut u32,

libs/libbreenix/src/graphics.rs

@@ -331,7 +331,10 @@ if [ "$PARALLELS" = true ]; then
 
     # VirtIO GPU with 3D acceleration (required for VirGL)
     prlctl set "$PARALLELS_VM" --3d-accelerate highest 2>/dev/null || true
-    prlctl set "$PARALLELS_VM" --videosize 128 2>/dev/null || true
+    prlctl set "$PARALLELS_VM" --videosize 256 2>/dev/null || true
+    # high-resolution OFF so the VM window maps 1:1 pixels-to-points on Retina Macs.
+    # With high-resolution ON, a 1280x960 guest appears as a tiny 640x480 point window.
+    prlctl set "$PARALLELS_VM" --high-resolution off 2>/dev/null || true
 
     # Remove any default devices Parallels created (cdrom, hdd, serial) to avoid conflicts
     for dev in hdd0 hdd1 hdd2 cdrom0 cdrom1 serial0 serial1; do

run.sh

@@ -17,10 +17,23 @@ EXT2_HDD_DIR="$PARALLELS_DIR/breenix-ext2.hdd"
 SERIAL_LOG="/tmp/breenix-parallels-serial.log"
 SCREENSHOT="/tmp/breenix-screenshot.png"
 
-echo "=== Building ==="
+echo "=== Building kernel ==="
 touch kernel/src/drivers/virtio/gpu_pci.rs
 scripts/parallels/build-efi.sh --kernel 2>&1 | grep -E "warning|error|Build Complete|bytes\)" | head -10
 
+echo "=== Building userspace + ext2 ==="
+./userspace/programs/build.sh --arch aarch64 2>&1 | tail -1
+./scripts/create_ext2_disk.sh --arch aarch64 >/dev/null 2>&1
+# Recreate ext2 Parallels HDD from fresh ext2 image
+EXT2_IMG="target/ext2-aarch64.img"
+if [ -f "$EXT2_IMG" ]; then
+    rm -rf "$EXT2_HDD_DIR"
+    prl_disk_tool create --hdd "$EXT2_HDD_DIR" --size 64M >/dev/null 2>&1
+    EXT2_HDS=$(find "$EXT2_HDD_DIR" -name "*.hds" | head -1)
+    cp "$EXT2_IMG" "$EXT2_HDS"
+    echo "ext2 HDD updated"
+fi
+
 LOADER_EFI="target/aarch64-unknown-uefi/release/parallels-loader.efi"
 KERNEL_ELF="target/aarch64-breenix/release/kernel-aarch64"
 
@@ -54,7 +67,8 @@ prlctl set "$VM_NAME" --memsize 2048 >/dev/null 2>&1
 prlctl set "$VM_NAME" --cpus 4 >/dev/null 2>&1
 prlctl set "$VM_NAME" --efi-boot on >/dev/null 2>&1 || true
 prlctl set "$VM_NAME" --3d-accelerate highest >/dev/null 2>&1 || true
-prlctl set "$VM_NAME" --videosize 128 >/dev/null 2>&1 || true
+prlctl set "$VM_NAME" --videosize 256 >/dev/null 2>&1 || true
+prlctl set "$VM_NAME" --high-resolution off >/dev/null 2>&1 || true
 for dev in hdd0 hdd1 hdd2 cdrom0 cdrom1 serial0 serial1; do
     prlctl set "$VM_NAME" --device-del "$dev" >/dev/null 2>&1 || true
 done

scripts/parallels/quick-test.sh

@@ -11,6 +11,7 @@ use std::process;
 use libbreenix::graphics;
 use libbreenix::graphics::{FlushRect, VirglRect};
 use libbreenix::time;
+use libbreenix::types;
 
 use libgfx::color::Color;
 use libgfx::font;
@@ -123,10 +124,29 @@ impl FpsCounter {
 
 const NUM_RECTS: usize = 6;
 
+/// Window buffer dimensions — a nice floating window size for the compositor.
+const WIN_W: u32 = 400;
+const WIN_H: u32 = 300;
+
 fn main() {
     let boot_id = clock_monotonic_ns();
     println!("Bounce demo starting (for Gus!) [boot_id={:016x}]", boot_id);
 
+    // Try window-buffer mode first: BWM composites us as a floating window
+    match graphics::create_window(WIN_W, WIN_H) {
+        Ok(win) => {
+            let _ = graphics::register_window(win.id, b"Bounce");
+            println!("[bounce] Window mode: id={} {}x{} @ {:p} [boot_id={:016x}]",
+                     win.id, WIN_W, WIN_H, win.pixels, boot_id);
+            let mut rects = make_rects();
+            run_window_loop(&win, &mut rects);
+            return;
+        }
+        Err(e) => {
+            println!("[bounce] create_window failed: {} — falling back to VirGL direct", e);
+        }
+    }
+
     let info = match graphics::fbinfo() {
         Ok(info) => info,
         Err(_e) => { println!("Error: Could not get framebuffer info"); process::exit(1); }
@@ -135,15 +155,7 @@ fn main() {
     let height = info.height as i32;
     let width = info.left_pane_width() as i32;
 
-    let mut rects = [
-        AnimRect::new( 50,  40,  900,  700,  120,  80, Color::rgb(255,  50,  50)),  // Red
-        AnimRect::new(200, 150, -800,  600,   90, 110, Color::rgb( 50, 255,  50)),  // Green
-        AnimRect::new(100, 300,  750, -850,  140,  60, Color::rgb( 50,  50, 255)),  // Blue
-        AnimRect::new(300, 100, -700, -750,   70, 130, Color::rgb(255, 255,  50)),  // Yellow
-        AnimRect::new(150, 400,  850,  500,  100, 100, Color::rgb(255,  50, 255)),  // Magenta
-        AnimRect::new(350, 250, -650,  800,  110,  70, Color::rgb( 50, 255, 255)),  // Cyan
-    ];
-
+    let mut rects = make_rects();
     let bg_packed = graphics::rgb(15, 15, 30);
 
     // Try VirGL GPU rendering first
@@ -160,6 +172,55 @@ fn main() {
     }
 }
 
+fn make_rects() -> [AnimRect; NUM_RECTS] {
+    [
+        AnimRect::new( 50,  40,  900,  700,  120,  80, Color::rgb(255,  50,  50)),  // Red
+        AnimRect::new(200, 150, -800,  600,   90, 110, Color::rgb( 50, 255,  50)),  // Green
+        AnimRect::new(100, 300,  750, -850,  140,  60, Color::rgb( 50,  50, 255)),  // Blue
+        AnimRect::new(300, 100, -700, -750,   70, 130, Color::rgb(255, 255,  50)),  // Yellow
+        AnimRect::new(150, 400,  850,  500,  100, 100, Color::rgb(255,  50, 255)),  // Magenta
+        AnimRect::new(350, 250, -650,  800,  110,  70, Color::rgb( 50, 255, 255)),  // Cyan
+    ]
+}
+
+/// Render bouncing rects into a window buffer. BWM composites this as a floating window.
+fn run_window_loop(win: &graphics::WindowBuffer, rects: &mut [AnimRect; NUM_RECTS]) {
+    let width = win.width as i32;
+    let height = win.height as i32;
+    let bpp = 4usize;
+    let stride = width as usize * bpp;
+    let bg = Color::rgb(15, 15, 30);
+
+    let mut fb = unsafe {
+        FrameBuf::from_raw(
+            win.pixels as *mut u8,
+            width as usize,
+            height as usize,
+            stride,
+            bpp,
+            true, // BGRA
+        )
+    };
+
+    let mut fps = FpsCounter::new();
+    const SUBSTEPS: i32 = 8;
+
+    loop {
+        for _ in 0..SUBSTEPS {
+            for rect in rects.iter_mut() { rect.step(SUBSTEPS); }
+            for rect in rects.iter_mut() { rect.bounce_walls(width, height); }
+        }
+
+        fb.clear(bg);
+        for rect in rects.iter() { rect.draw(&mut fb); }
+        fps.tick();
+        fps.draw(&mut fb);
+
+        // Throttle to ~60 FPS — BWM reads our buffer each frame anyway
+        let _ = time::nanosleep(&libbreenix::types::Timespec { tv_sec: 0, tv_nsec: 16_000_000 });
+    }
+}
+
 fn build_virgl_rects(rects: &[AnimRect; NUM_RECTS]) -> [VirglRect; NUM_RECTS] {
     let mut vr = [VirglRect::default(); NUM_RECTS];
     for (i, rect) in rects.iter().enumerate() {