monolith

public

Star0

Fork 0

Watch0

160 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `0f99c9f9166b`

tarball

atagen <boss@atagen.co>2026-10-19 07:51 UTC

1 file changed+82-7

drm: retry failed frames and recover lost page flips

`render_surface` reset `redraw` to `animating` after a `render_frame` or `queue_frame` error, so the stale image stayed until something unrelated redrew. Failures now keep the request and retry with a capped backoff. A flip watchdog clears `queued` when a vblank never arrives, which `DrmEvent::Error` can cause and which otherwise wedged the output for good.

Modified file: crates/monolith/src/drm.rs+82 additions−7 deletions@@ -73,6 +73,11 @@ struct Surface {
     drm: Out,
     /// A frame is on its way to the screen and its vblank has not landed.
     queued: bool,
+    queued_at: u64,
+    /// Fires when a queued frame's vblank never arrives.
+    watchdog: Option<RegistrationToken>,
+    /// Consecutive frames that failed to render or queue.
+    failures: u32,
     redraw: bool,
     last_vblank_ns: Option<u64>,
     refresh_ns: u64,
@@ -105,6 +110,12 @@ impl Surface {
     fn next_deadline(&self, now: u64) -> Option<(u64, u64)> {
         crate::pacing::deadline(self.last_vblank_ns?, self.refresh_ns, self.budget.ns(), now)
     }
+
+    /// How long a queued frame may go without its vblank. Under VRR a flip
+    /// waits for the panel's longest frame, so the floor stays well above it.
+    fn flip_timeout(&self) -> u64 {
+        (self.refresh_ns * 4).max(100_000_000)
+    }
 }
 
 /// The GPU monolith drives on bare metal, the seat's primary or else its
@@ -392,6 +403,9 @@ fn connect(state: &mut State, connector: connector::Info, crtc: crtc::Handle) {
             id,
             drm: out,
             queued: false,
+            queued_at: 0,
+            watchdog: None,
+            failures: 0,
             redraw: true,
             last_vblank_ns: None,
             scheduled: None,
@@ -516,7 +530,7 @@ fn disconnect(state: &mut State, crtc: crtc::Handle) {
     let Some(surface) = drm.surfaces.remove(&crtc) else {
         return;
     };
-    if let Some(token) = surface.scheduled {
+    for token in [surface.scheduled, surface.watchdog].into_iter().flatten() {
         drm.handle.remove(token);
     }
     tracing::info!(name = surface.output.name(), "output disconnected");
@@ -677,6 +691,54 @@ fn arm(
     }
 }
 
+/// Arms the flip watchdog unless it already runs.
+fn watch(handle: &LoopHandle<'static, State>, surface: &mut Surface, crtc: crtc::Handle) {
+    if surface.watchdog.is_some() {
+        return;
+    }
+    let after = Duration::from_nanos(surface.flip_timeout());
+    let token = handle.insert_source(Timer::from_duration(after), move |_, _, state| {
+        flip_watchdog(state, crtc)
+    });
+    match token {
+        Ok(token) => surface.watchdog = Some(token),
+        Err(e) => tracing::warn!(
+            output = surface.output.name(),
+            "could not arm the flip watchdog: {e}"
+        ),
+    }
+}
+
+/// Recovers an output whose page flip event never came, as after a
+/// `DrmEvent::Error`, so `queued` cannot hold it dark forever.
+fn flip_watchdog(state: &mut State, crtc: crtc::Handle) -> TimeoutAction {
+    let Some(drm) = state.backend.drm_mut() else {
+        return TimeoutAction::Drop;
+    };
+    let active = drm.session.is_active();
+    let Some(surface) = drm.surfaces.get_mut(&crtc) else {
+        return TimeoutAction::Drop;
+    };
+    let age = now_ns().saturating_sub(surface.queued_at);
+    let limit = surface.flip_timeout();
+    if active && surface.queued && age < limit {
+        return TimeoutAction::ToDuration(Duration::from_nanos(limit - age));
+    }
+    surface.watchdog = None;
+    if !active || !surface.queued {
+        return TimeoutAction::Drop;
+    }
+    tracing::warn!(output = surface.output.name(), "page flip never landed");
+    if let Err(e) = surface.drm.frame_submitted() {
+        tracing::warn!("frame was not submitted: {e}");
+    }
+    surface.queued = false;
+    surface.target_ns = None;
+    surface.redraw = true;
+    schedule(state, crtc);
+    TimeoutAction::Drop
+}
+
 /// An animation whose frame had nothing to show, like one hidden behind a
 /// fullscreen window, has no flip to wait for. Under VRR scheduling again
 /// would draw at once and recurse until the stack overflowed, so the next
@@ -694,8 +756,11 @@ fn draw(state: &mut State, crtc: crtc::Handle, target: u64) {
     if surface.scheduled.is_some() {
         return;
     }
-    let wait = Duration::from_nanos(surface.refresh_ns.max(1_000_000));
-    arm(&drm.handle, surface, crtc, wait, true, move |state| {
+    let backoff = surface.failures.saturating_sub(1).min(6);
+    let wait = (surface.refresh_ns.max(1_000_000) << backoff).min(1_000_000_000);
+    let wait = Duration::from_nanos(wait);
+    let preemptible = surface.failures == 0;
+    arm(&drm.handle, surface, crtc, wait, preemptible, move |state| {
         schedule(state, crtc);
     });
 }
@@ -804,6 +869,7 @@ fn render_surface(state: &mut State, crtc: crtc::Handle, target: u64) -> bool {
     let render_began = std::time::Instant::now();
     let cpu_began = thread_cpu_ns();
     let mut queue_ns = 0;
+    let mut failed = false;
     match surface
         .drm
         .render_frame(renderer, &elements, CLEAR, drm.frame_flags)
@@ -828,15 +894,23 @@ fn render_surface(state: &mut State, crtc: crtc::Handle, target: u64) -> bool {
             match surface.drm.queue_frame(()) {
                 Ok(()) => {
                     surface.queued = true;
+                    surface.queued_at = now_ns();
+                    watch(&drm.handle, surface, crtc);
                     lock.shown(&surface.output);
                     captures.output_damaged(&surface.output);
                 }
-                Err(e) => tracing::warn!("queueing a frame failed: {e}"),
+                Err(e) => {
+                    failed = true;
+                    tracing::warn!("queueing a frame failed: {e}");
+                }
             }
             queue_ns = queue_began.elapsed().as_nanos() as u64;
         }
         Ok(_) => lock.shown(&surface.output),
-        Err(e) => tracing::warn!("rendering failed: {e}"),
+        Err(e) => {
+            failed = true;
+            tracing::warn!("rendering failed: {e}");
+        }
     }
     let render_cpu_ns = thread_cpu_ns() - cpu_began;
     let render_ns = render_began.elapsed().as_nanos() as u64 - queue_ns;
@@ -857,10 +931,11 @@ fn render_surface(state: &mut State, crtc: crtc::Handle, target: u64) -> bool {
     if !surface.queued {
         surface.target_ns = None;
     }
-    surface.redraw = animating;
+    surface.failures = if failed { surface.failures + 1 } else { 0 };
+    surface.redraw = animating || failed;
     let elapsed = core.start.elapsed();
     crate::frame::send_frame_callbacks(wm, lock, surface.id, &surface.output, now, elapsed);
-    animating && !surface.queued
+    (animating || failed) && !surface.queued
 }
 
 /// CPU time this thread has used, to tell a render that works from one that

monolith

Commit 0f99c9f9166b

Commit `0f99c9f9166b`