fix: pass z-order from BWM to kernel for correct GPU compositing order

Windows were drawn in slot order rather than z-order, causing window
decorations to appear behind other windows' content. BWM now passes
z_order (vec index) via set_window_position op=17, and the kernel
sorts WindowCompositeInfo by z_order before GPU draws back-to-front.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: ryanbreen

kernel/src/syscall/graphics.rs

@@ -188,6 +188,8 @@ struct WindowBuffer {
     /// Window position (set by compositor)
     x: i32,
     y: i32,
+    /// Z-order (0 = bottom, higher = closer to viewer). Set by compositor.
+    z_order: u32,
     /// VirGL TEXTURE_2D resource ID (0 = not initialized)
     virgl_resource_id: u32,
     /// Whether VirGL texture has been created + backed + primed
@@ -279,6 +281,7 @@ impl WindowRegistry {
             title_len: 0,
             x: 0,
             y: 0,
+            z_order: 0,
             virgl_resource_id: 0,
             virgl_initialized: false,
             generation: 0,
@@ -918,16 +921,18 @@ fn handle_virgl_op(cmd: &FbDrawCmd) -> SyscallResult {
             handle_composite_windows(desc_ptr)
         }
         17 => {
-            // SetWindowPosition: set window position for compositor
-            // p1=buffer_id, p2=x (i16 low) | y (i16 high)
+            // SetWindowPosition: set window position + z-order for compositor
+            // p1=buffer_id, p2=x (i16 low) | y (i16 high), p3=z_order
             let buffer_id = cmd.p1 as u32;
             let x = (cmd.p2 & 0xFFFF) as i16 as i32;
             let y = ((cmd.p2 >> 16) & 0xFFFF) as i16 as i32;
+            let z_order = cmd.p3 as u32;
             let mut reg = WINDOW_REGISTRY.lock();
             match reg.find_mut(buffer_id) {
                 Some(buf) => {
                     buf.x = x;
                     buf.y = y;
+                    buf.z_order = z_order;
                     SyscallResult::Ok(0)
                 }
                 None => SyscallResult::Err(super::ErrorCode::InvalidArgument as u64),
@@ -1456,6 +1461,7 @@ fn handle_composite_windows(desc_ptr: u64) -> SyscallResult {
                     height: buf.height,
                     x: buf.x,
                     y: buf.y,
+                    z_order: buf.z_order,
                     dirty,
                     page_phys_addrs: buf.page_phys_addrs.clone(),
                     size: buf.size,
@@ -1472,6 +1478,8 @@ fn handle_composite_windows(desc_ptr: u64) -> SyscallResult {
                 win_idx += 1;
             }
         }
+        // Sort by z_order so GPU draws back-to-front (lower z = drawn first).
+        result.sort_unstable_by_key(|w| w.z_order);
         result
     };
 
@@ -1536,6 +1544,7 @@ pub struct WindowCompositeInfo {
     pub height: u32,
     pub x: i32,
     pub y: i32,
+    pub z_order: u32,
     pub dirty: bool,
     pub page_phys_addrs: alloc::vec::Vec<u64>,
     pub size: usize,

libs/libbreenix/src/graphics.rs

@@ -567,13 +567,13 @@ pub fn mark_window_dirty(buffer_id: u32) -> Result<(), Error> {
 ///
 /// Tells the kernel where to place this window during compositing.
 /// If position is never set, windows are auto-positioned.
-pub fn set_window_position(buffer_id: u32, x: i32, y: i32) -> Result<(), Error> {
+pub fn set_window_position(buffer_id: u32, x: i32, y: i32, z_order: u32) -> Result<(), Error> {
     let packed_xy = ((x as u16 as u32) | ((y as u16 as u32) << 16)) as i32;
     let cmd = FbDrawCmd {
         op: draw_op::SET_WINDOW_POSITION,
         p1: buffer_id as i32,
         p2: packed_xy,
-        p3: 0,
+        p3: z_order as i32,
         p4: 0,
         color: 0,
     };

userspace/programs/src/bwm.rs

@@ -604,10 +604,13 @@ fn discover_windows(windows: &mut Vec<Window>, screen_w: usize, screen_h: usize,
             core::str::from_utf8(&title[..title_len]).unwrap_or("?"),
             info.buffer_id, info.width, info.height, cascade_x, cascade_y);
 
-        // Tell kernel where the client content goes on screen (for GPU compositing)
+        // Tell kernel where the client content goes on screen (for GPU compositing).
+        // z_order = index in windows vec (0 = bottom). New windows are pushed to
+        // the end, so they get the highest z_order.
         let content_x = cascade_x + BORDER_WIDTH as i32;
         let content_y = cascade_y + TITLE_BAR_HEIGHT as i32 + BORDER_WIDTH as i32;
-        let _ = graphics::set_window_position(info.buffer_id, content_x, content_y);
+        let z_order = windows.len() as u32; // will be at this index after push
+        let _ = graphics::set_window_position(info.buffer_id, content_x, content_y, z_order);
 
         let order = *next_order;
         *next_order += 1;
@@ -624,6 +627,17 @@ fn discover_windows(windows: &mut Vec<Window>, screen_w: usize, screen_h: usize,
     removed || added
 }
 
+/// Update kernel z-order for all windows. Called after any z-order change
+/// (raise-to-front, new window, etc.) so the GPU compositor draws quads
+/// in correct back-to-front order.
+fn update_kernel_z_order(windows: &[Window]) {
+    for (i, win) in windows.iter().enumerate() {
+        if win.window_id != 0 {
+            let _ = graphics::set_window_position(win.window_id, win.content_x(), win.content_y(), i as u32);
+        }
+    }
+}
+
 /// Redraw all windows in z-order (index 0 = bottom), plus taskbar and app bar.
 /// Window frames and decorations go into the compositor buffer; GPU compositing
 /// handles client content via per-window textured quads.
@@ -882,6 +896,7 @@ fn main() {
                 // New windows are pushed to end of Vec (top of z-order).
                 // Always focus the topmost visible window so appbar selection
                 // matches the visually foregrounded window.
+                update_kernel_z_order(&windows);
                 focused_win = next_visible_window(&windows, 0);
                 compose_full_redraw(composite_buf, &mut fb, &mut shadow_fb, &bg_cache, &windows, focused_win, &clock_text);
                 full_redraw = true;
@@ -961,7 +976,7 @@ fn main() {
                             if windows[win_idx].window_id != 0 {
                                 let cx = windows[win_idx].content_x();
                                 let cy = windows[win_idx].content_y();
-                                let _ = graphics::set_window_position(windows[win_idx].window_id, cx, cy);
+                                let _ = graphics::set_window_position(windows[win_idx].window_id, cx, cy, win_idx as u32);
                             }
                             // Dirty region = union of old and new bounds
                             let (nx0, ny0, nx1, ny1) = windows[win_idx].bounds();
@@ -1028,6 +1043,7 @@ fn main() {
                                 if idx < windows.len() - 1 {
                                     let win = windows.remove(idx);
                                     windows.push(win);
+                                    update_kernel_z_order(&windows);
                                 }
                                 let top = windows.len() - 1;
                                 if top != focused_win {
@@ -1060,6 +1076,7 @@ fn main() {
                             if ci < windows.len() - 1 {
                                 let win = windows.remove(ci);
                                 windows.push(win);
+                                update_kernel_z_order(&windows);
                             }
                             let top = windows.len() - 1;