Phase 4 vraie — pipeline OK, verrou fbbootlogd identifié

Crates ajoutés :
- redox-wl-display (lib) : RedoxOutput { open, take_crtc, pixels_mut,
  present, present_with_takeover, Drop }
- redox-wl-fullscreen-paint (bin) : take CRTC + 30 frames ARGB animées

Validation logique du pipeline display sur Redox bootée :
- ConsumerHandle::new_vt() OK
- open_display_v2() retourne le fd graphics-ipc
- V2GraphicsHandle énumère 1 connecteur 1280x800
- CpuBackedBuffer ARGB8888 plein écran allocable
- add_framebuffer + set_crtc + dirty_framebuffer répondent tous OK
- 30 itérations sync_rect sans erreur ni leak

Validation visuelle automatisée via QEMU monitor screendump :
- QEMU en -display none + -monitor unix:socket
- ncat -U envoie sendkey ret au bootloader puis screendump à T+15s
- ImageMagick convertit PPM → PNG, visualisable

Verrou identifié : fbbootlogd (lancé par init.initfs.d/20_fbbootlogd.service,
embarqué dans le blob initfs) écrit directement dans le framebuffer mémoire
mappé par vesad, hors du pipeline DRM. Il ne release pas le display quand
notre paint fait set_crtc.

Pour vrai visuel, il faut soit :
1. Consommer les events VT côté RedoxOutput (le pattern Orbital, propre)
2. Désactiver fbbootlogd dans l'image (rapide, debug)
3. Implémenter le handoff complet (long, prod)

Le pipeline étant validé, on peut passer phase 5 (input backend) et revenir
sur le visuel quand on aura un compositor qui consomme les events VT.

docs/phase4-display-backend.md enrichi avec l'analyse complète.

Leyoda 2026 – GPLv3

crates/redox-wl-display/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "redox-wl-display"
+version = "0.1.0"
+edition = "2021"
+description = "Display backend wrapper around graphics-ipc + drm subset for Redox"
+
+[dependencies]
+drm = "0.15"
+graphics-ipc = { git = "https://gitlab.redox-os.org/redox-os/base.git" }
+inputd = { git = "https://gitlab.redox-os.org/redox-os/base.git" }

crates/redox-wl-display/src/lib.rs

@@ -0,0 +1,203 @@
+//! Display backend wrapper for Redox.
+//!
+//! Réutilise le pattern d'Orbital (cf orbital/src/core/display.rs) en exposant
+//! une API minimaliste pour un compositor :
+//!
+//!   let mut output = RedoxOutput::open()?;
+//!   output.take_crtc()?;          // alloue framebuffer + set_crtc
+//!   {
+//!       let pixels = output.pixels_mut()?;
+//!       // peindre dans pixels
+//!   }
+//!   output.present()?;            // sync_rect + dirty_framebuffer
+//!   // Drop libère framebuffer + buffer
+//!
+//! Pour l'instant : un seul connecteur, un seul mode (le premier renvoyé par
+//! le KMS Redox), pas de page flip / double buffer / hotplug.
+
+use std::io;
+use std::slice;
+
+use drm::Device as _;
+use drm::buffer::{Buffer as _, DrmFourcc};
+use drm::control::{
+    ClipRect, Device as _, Mode, connector,
+    crtc as drm_crtc, framebuffer,
+};
+use graphics_ipc::{CpuBackedBuffer, V2GraphicsHandle};
+use inputd::ConsumerHandle;
+
+pub struct RedoxOutput {
+    handle: V2GraphicsHandle,
+    width: u32,
+    height: u32,
+    connector: connector::Handle,
+    crtc: drm_crtc::Handle,
+    mode: Mode,
+    fb: Option<framebuffer::Handle>,
+    buffer: Option<CpuBackedBuffer>,
+}
+
+impl RedoxOutput {
+    /// Ouvre le display via inputd → graphics-ipc, choisit le premier
+    /// connecteur connecté + son premier mode + le premier CRTC compatible.
+    pub fn open() -> io::Result<Self> {
+        let consumer = ConsumerHandle::new_vt()?;
+        let display_file = consumer.open_display_v2()?;
+        let handle = V2GraphicsHandle::from_file(display_file)?;
+
+        let resources = handle.resource_handles().map_err(io::Error::other)?;
+
+        // First connected connector
+        let mut chosen: Option<(connector::Handle, _)> = None;
+        for &c in resources.connectors() {
+            let info = handle.get_connector(c, true)?;
+            if info.state() == connector::State::Connected {
+                chosen = Some((c, info));
+                break;
+            }
+        }
+        let (connector, info) =
+            chosen.ok_or_else(|| io::Error::other("no connected display"))?;
+
+        let mode = info
+            .modes()
+            .first()
+            .copied()
+            .ok_or_else(|| io::Error::other("connector has no mode"))?;
+        let (w, h) = mode.size();
+
+        let encoder_handle = info
+            .encoders()
+            .first()
+            .copied()
+            .ok_or_else(|| io::Error::other("connector has no encoder"))?;
+        let encoder = handle.get_encoder(encoder_handle)?;
+        let crtc = resources
+            .filter_crtcs(encoder.possible_crtcs())
+            .first()
+            .copied()
+            .ok_or_else(|| io::Error::other("no crtc compatible with encoder"))?;
+
+        Ok(Self {
+            handle,
+            width: w as u32,
+            height: h as u32,
+            connector,
+            crtc,
+            mode,
+            fb: None,
+            buffer: None,
+        })
+    }
+
+    pub fn width(&self) -> u32 {
+        self.width
+    }
+    pub fn height(&self) -> u32 {
+        self.height
+    }
+    pub fn handle(&self) -> &V2GraphicsHandle {
+        &self.handle
+    }
+
+    /// Alloue un CpuBackedBuffer ARGB8888 plein écran, l'ajoute comme
+    /// framebuffer DRM et appelle `set_crtc` pour qu'il soit affiché.
+    /// Le binaire qui appelle ça doit être l'unique handler du VT cible
+    /// (sinon Orbital ou un autre serveur va se battre pour le CRTC).
+    pub fn take_crtc(&mut self) -> io::Result<()> {
+        if self.fb.is_some() || self.buffer.is_some() {
+            return Err(io::Error::other("CRTC already taken"));
+        }
+
+        let buffer = CpuBackedBuffer::new(
+            &self.handle,
+            (self.width, self.height),
+            DrmFourcc::Argb8888,
+            32,
+        )?;
+        let fb = self.handle.add_framebuffer(buffer.buffer(), 32, 32)?;
+        self.handle.set_crtc(
+            self.crtc,
+            Some(fb),
+            (0, 0),
+            &[self.connector],
+            Some(self.mode),
+        )?;
+
+        self.fb = Some(fb);
+        self.buffer = Some(buffer);
+        Ok(())
+    }
+
+    /// Renvoie une slice mutable des pixels au format `u32` (ARGB8888,
+    /// little-endian → mémoire BGRA octet par octet, mais en u32 c'est
+    /// directement 0xAARRGGBB).
+    pub fn pixels_mut(&mut self) -> io::Result<&mut [u32]> {
+        let buffer = self
+            .buffer
+            .as_mut()
+            .ok_or_else(|| io::Error::other("CRTC not taken yet"))?;
+        let bytes = buffer.shadow_buf();
+        let (w, h) = (self.width as usize, self.height as usize);
+        // SAFETY: alignment 4 garantie par DumbBuffer ARGB8888 + len % 4 == 0
+        let pixels = unsafe {
+            slice::from_raw_parts_mut(bytes.as_mut_ptr() as *mut u32, w * h)
+        };
+        Ok(pixels)
+    }
+
+    /// Pousse le contenu du buffer sur l'écran. Appel l'équivalent de
+    /// `wl_surface.commit` côté Wayland — ici on fait un sync_rect
+    /// (shadow → on-screen) + dirty_framebuffer (notification au driver).
+    pub fn present(&mut self) -> io::Result<()> {
+        let fb = self.fb.ok_or_else(|| io::Error::other("no fb"))?;
+        let buffer = self
+            .buffer
+            .as_mut()
+            .ok_or_else(|| io::Error::other("no buffer"))?;
+        buffer.sync_rect(0, 0, self.width, self.height);
+        self.handle.dirty_framebuffer(
+            fb,
+            &[ClipRect::new(0, 0, self.width as u16, self.height as u16)],
+        )?;
+        Ok(())
+    }
+
+    /// Variante de `present` qui ré-applique `set_crtc` AVANT le flush.
+    /// Utile en démarrage si un autre serveur (fbbootlogd) tient encore
+    /// le CRTC malgré notre `take_crtc` initial. À appeler à chaque frame
+    /// au début, à enlever quand on est sûr de tenir le display.
+    pub fn present_with_takeover(&mut self) -> io::Result<()> {
+        let fb = self.fb.ok_or_else(|| io::Error::other("no fb"))?;
+        // Re-forcer set_crtc : repren le CRTC si quelqu'un d'autre l'avait pris
+        self.handle.set_crtc(
+            self.crtc,
+            Some(fb),
+            (0, 0),
+            &[self.connector],
+            Some(self.mode),
+        )?;
+        let buffer = self
+            .buffer
+            .as_mut()
+            .ok_or_else(|| io::Error::other("no buffer"))?;
+        buffer.sync_rect(0, 0, self.width, self.height);
+        self.handle.dirty_framebuffer(
+            fb,
+            &[ClipRect::new(0, 0, self.width as u16, self.height as u16)],
+        )?;
+        Ok(())
+    }
+}
+
+impl Drop for RedoxOutput {
+    fn drop(&mut self) {
+        if let Some(fb) = self.fb.take() {
+            let _ = self.handle.destroy_framebuffer(fb);
+        }
+        if let Some(buffer) = self.buffer.take() {
+            let _ = buffer.destroy(&self.handle);
+        }
+    }
+}

crates/redox-wl-fullscreen-paint/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "redox-wl-fullscreen-paint"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+redox-wl-display = { path = "../redox-wl-display" }

crates/redox-wl-fullscreen-paint/src/main.rs

@@ -0,0 +1,122 @@
+//! Phase 4 vraie : prendre le CRTC + dessiner plein écran.
+//!
+//! Ce binaire est destiné à *remplacer* Orbital sur le VT 3 dans l'init
+//! Redox (modifier `usr/lib/init.d/20_orbital`). Il :
+//!
+//! 1. Lit `VT` env var (mise par init)
+//! 2. Ouvre le display via inputd → graphics-ipc
+//! 3. Appelle `inputd -A <vt>` pour devenir handler officiel du VT
+//! 4. Prend le CRTC (set_crtc avec un framebuffer plein écran)
+//! 5. Peint un dégradé ARGB8888 + bandes diagonales animées sur 30 frames
+//! 6. Présente une frame par seconde pendant 30 secondes
+//! 7. Exit propre — Drop libère le framebuffer
+//!
+//! Pendant ces 30 s, l'écran QEMU montre **les pixels écrits par notre code**,
+//! pas le login Orbital. Premier vrai signal visuel d'un compositor naissant.
+
+use std::env;
+use std::fs::OpenOptions;
+use std::io::Write;
+use std::process::{Command, ExitCode};
+use std::sync::{Mutex, OnceLock};
+use std::thread;
+use std::time::Duration;
+
+use redox_wl_display::RedoxOutput;
+
+/// Mirroir stdout sur /scheme/debug pour que la sortie aille au serial host.
+struct DebugSink(Mutex<Option<std::fs::File>>);
+impl DebugSink {
+    fn new() -> Self {
+        Self(Mutex::new(
+            OpenOptions::new().write(true).open("/scheme/debug").ok(),
+        ))
+    }
+    fn writeln(&self, s: &str) {
+        println!("{s}");
+        if let Ok(mut g) = self.0.lock() {
+            if let Some(f) = g.as_mut() {
+                let _ = writeln!(f, "{s}");
+            }
+        }
+    }
+}
+fn dlog(s: &str) {
+    static SINK: OnceLock<DebugSink> = OnceLock::new();
+    SINK.get_or_init(DebugSink::new).writeln(s);
+}
+
+/// Pixel ARGB8888 calculé depuis (x, y, t) : bande diagonale qui se déplace
+/// avec t pour qu'on voie l'écran s'animer (preuve que la boucle render tourne).
+fn pixel(x: u32, y: u32, w: u32, h: u32, t: u32) -> u32 {
+    let r = ((x * 255) / w.max(1)) & 0xFF;
+    let g = ((y * 255) / h.max(1)) & 0xFF;
+    let b = ((x.wrapping_add(y).wrapping_add(t.wrapping_mul(8))) & 0xFF) as u32;
+    (0xFF << 24) | (r << 16) | (g << 8) | b
+}
+
+fn run() -> Result<(), Box<dyn std::error::Error>> {
+    dlog("[paint] Phase 4 vraie — prendre CRTC + dessiner plein écran");
+
+    let vt = env::var("VT").ok();
+    dlog(&format!("[paint] VT = {:?}", vt));
+
+    let mut output = RedoxOutput::open().map_err(|e| format!("RedoxOutput::open: {e}"))?;
+    dlog(&format!(
+        "[paint] display ouvert : {}x{}",
+        output.width(),
+        output.height()
+    ));
+
+    if let Some(v) = &vt {
+        match Command::new("inputd").arg("-A").arg(v).status() {
+            Ok(s) if s.success() => dlog(&format!("[paint] inputd -A {v} OK")),
+            Ok(s) => dlog(&format!("[paint] inputd -A {v} exit {:?}", s)),
+            Err(e) => dlog(&format!("[paint] inputd -A {v} err: {e}")),
+        }
+    }
+
+    output.take_crtc().map_err(|e| format!("take_crtc: {e}"))?;
+    dlog("[paint] CRTC pris : on tient l'écran");
+
+    let w = output.width();
+    let h = output.height();
+
+    // 30 frames espacées d'une seconde pour qu'on voie le dégradé bouger
+    for t in 0..30u32 {
+        {
+            let pixels = output.pixels_mut()?;
+            for y in 0..h {
+                let row = (y * w) as usize;
+                for x in 0..w {
+                    pixels[row + x as usize] = pixel(x, y, w, h, t);
+                }
+            }
+        }
+        output
+            .present_with_takeover()
+            .map_err(|e| format!("present {t}: {e}"))?;
+        if t % 5 == 0 {
+            dlog(&format!("[paint] frame {t}/30 présentée"));
+        }
+        thread::sleep(Duration::from_millis(1000));
+    }
+
+    dlog("[paint] 30 frames terminées, exit propre");
+    drop(output); // libère framebuffer + buffer explicitement
+    thread::sleep(Duration::from_millis(500)); // laisser le serial flush
+    Ok(())
+}
+
+fn main() -> ExitCode {
+    match run() {
+        Ok(()) => {
+            dlog("[paint] PASS");
+            ExitCode::SUCCESS
+        }
+        Err(e) => {
+            dlog(&format!("[paint] FAIL: {e}"));
+            ExitCode::FAILURE
+        }
+    }
+}