fix: VirtIO GPU driver and snake rendering through display server

- Fix swapped command IDs: attach_backing was 0x0104 (FLUSH),
  resource_flush was 0x0106 (ATTACH_BACKING). Now correct.
- Increase process stack from 4 pages (16 KB) to 16 pages (64 KB)
  to prevent stack overflow in display process.
- Restructure display-qemu to avoid MockFramebuffer's 32 KB array
  inflating the VirtIO path's stack frame.
- Wire snake app to render through display server via IPC instead
  of UART escape codes. Uses existing renderer.rs pixel renderer.
- Init now delegates display endpoint to snake process.

crates/apps/snake/Cargo.toml

@@ -12,3 +12,5 @@ bench = false
 types = { workspace = true }
 userspace = { workspace = true }
 userspace-rt = { workspace = true }
+display-server = { workspace = true }
+server-framework = { workspace = true }

crates/apps/snake/src/main.rs

@@ -3,119 +3,70 @@
 
 extern crate userspace_rt;
 
-use snake::game::{Direction, GameState, Snake, GRID_WIDTH, GRID_HEIGHT};
+use snake::game::{Direction, GameState, Snake};
+use snake::renderer::{self, RenderCommand};
 use types::bounded::CapSlot;
+use types::display::{Color, Dimension, ScreenCoord};
 use types::time::Ticks;
 use userspace_rt::syscall;
+use server_framework::Encode;
+use display_server::protocol::DisplayRequest;
 
 const INPUT_EP: CapSlot = CapSlot::const_new(0);
+const DISPLAY_EP: CapSlot = CapSlot::const_new(1);
 const TICK_DELAY: u64 = 2_000_000;
+const MAX_RENDER_CMDS: usize = 140;
 
-fn putchar(c: u8) { syscall::debug_putchar(c); }
-fn puts(s: &[u8]) { for &b in s { putchar(b); } }
-
-fn move_cursor(row: u16, col: u16) {
-    puts(b"\x1b[");
-    print_dec(row + 1);
-    putchar(b';');
-    print_dec(col + 1);
-    putchar(b'H');
+fn display_send(req: &DisplayRequest) {
+    let words = req.encode();
+    syscall::send(DISPLAY_EP, words[0], words[1], words[2], words[3]);
+    syscall::receive(DISPLAY_EP);
 }
 
-fn print_dec(mut v: u16) {
-    if v == 0 { putchar(b'0'); return; }
-    let mut buf = [0u8; 5];
-    let mut i = 0;
-    while v > 0 { buf[i] = b'0' + (v % 10) as u8; v /= 10; i += 1; }
-    while i > 0 { i -= 1; putchar(buf[i]); }
+fn draw_rect(x: u16, y: u16, w: u16, h: u16, color: u32) {
+    display_send(&DisplayRequest::DrawRect {
+        x: ScreenCoord::new(x),
+        y: ScreenCoord::new(y),
+        w: Dimension::new(w),
+        h: Dimension::new(h),
+        color: Color::from_raw(color),
+    });
 }
 
-fn set_color(fg: u8) {
-    puts(b"\x1b[");
-    print_dec(fg as u16);
-    putchar(b'm');
+fn flush() {
+    display_send(&DisplayRequest::Flush);
 }
 
 #[unsafe(no_mangle)]
 extern "C" fn main() {
     let mut snake = Snake::new();
-
-    puts(b"\x1b[2J"); // clear screen
-    puts(b"\x1b[?25l"); // hide cursor
-
-    // Draw border
-    set_color(90); // dark grey
-    move_cursor(0, 0);
-    for _ in 0..GRID_WIDTH + 2 { putchar(b'#'); }
-    for y in 0..GRID_HEIGHT {
-        move_cursor(y + 1, 0);
-        putchar(b'#');
-        move_cursor(y + 1, GRID_WIDTH + 1);
-        putchar(b'#');
-    }
-    move_cursor(GRID_HEIGHT + 1, 0);
-    for _ in 0..GRID_WIDTH + 2 { putchar(b'#'); }
+    let mut commands = [RenderCommand { x: 0, y: 0, w: 0, h: 0, color: 0 }; MAX_RENDER_CMDS];
 
     loop {
-        // Render
-        render_game(&snake);
+        let count = renderer::render(&snake, &mut commands);
+        for i in 0..count {
+            let cmd = &commands[i];
+            draw_rect(cmd.x, cmd.y, cmd.w, cmd.h, cmd.color);
+        }
+        flush();
 
         wait_tick();
         handle_input(&mut snake);
         snake.tick();
 
         if snake.state() == GameState::GameOver {
-            move_cursor(GRID_HEIGHT / 2, GRID_WIDTH / 2 - 4);
-            set_color(91); // bright red
-            puts(b"GAME OVER");
-            set_color(0);
-            move_cursor(GRID_HEIGHT + 3, 0);
-            puts(b"Score: ");
-            print_dec(snake.score());
-            putchar(b'\n');
+            let gw = renderer::grid_pixel_width();
+            let gh = renderer::grid_pixel_height();
+            draw_rect(gw / 2 - 60, gh / 2 - 12, 120, 24, 0xFF800000);
+            flush();
 
             let end = Ticks::from_raw(syscall::get_time().raw() + 50_000_000);
             while syscall::get_time().raw() < end.raw() { syscall::yield_now(); }
-            puts(b"\x1b[?25h"); // show cursor
             return;
         }
     }
 }
 
-fn render_game(snake: &Snake) {
-    // Clear game area
-    for y in 0..GRID_HEIGHT {
-        move_cursor(y + 1, 1);
-        for _ in 0..GRID_WIDTH { putchar(b' '); }
-    }
-
-    // Draw food
-    let food = snake.food();
-    move_cursor(food.y + 1, food.x + 1);
-    set_color(91); // bright red
-    putchar(b'@');
-
-    // Draw snake body
-    let body = snake.body();
-    for (i, pos) in body.iter().enumerate() {
-        move_cursor(pos.y + 1, pos.x + 1);
-        if i == 0 {
-            set_color(92); // bright green
-            putchar(b'O'); // head
-        } else {
-            set_color(32); // green
-            putchar(b'o'); // body
-        }
-    }
-
-    // Score
-    set_color(0);
-    move_cursor(GRID_HEIGHT + 2, 0);
-    puts(b"Score: ");
-    print_dec(snake.score());
-    puts(b"  WASD to move");
-}
-
 fn handle_input(snake: &mut Snake) {
     let _ = syscall::send(INPUT_EP, 0, 0, 0, 0);
     let (tag, kind, _, _) = syscall::receive(INPUT_EP);