monolith

public

Star0

Fork 0

Watch0

162 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `cac2b35598c9`

tarball

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

3 files changed+112-6

drm: handle monitor unplug, replug and rescans properly

The `GlobalId` from `Output::create_global` was dropped, so clients kept phantom wl_outputs and saw duplicates after a replug. Layer surfaces and lock surfaces stayed on the dead `Output`. `DrmScanEvent::Changed` (the EDID race) was ignored, and a connector whose `connect` failed was never retried because the scanner had already recorded it. Nothing rescanned on VT return, and a udev change during a paused session modeset on a revoked fd.

Modified file: crates/monolith/src/drm.rs+93 additions−6 deletions@@ -35,10 +35,11 @@ use smithay::reexports::drm::Device as _;
 use smithay::reexports::drm::control::{self, ModeTypeFlags, connector, crtc};
 use smithay::reexports::input::Libinput;
 use smithay::reexports::rustix::fs::OFlags;
+use smithay::reexports::wayland_server::backend::GlobalId;
 use smithay::utils::{DeviceFd, Logical, Point, Transform};
 use smithay::wayland::drm_syncobj::{DrmSyncobjState, supports_syncobj_eventfd};
 use smithay_drm_extras::drm_scanner::{DrmScanEvent, DrmScanner};
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 use std::path::{Path, PathBuf};
 use std::time::Duration;
 
@@ -47,6 +48,10 @@ use crate::frame::{CLEAR, FrameCtx};
 /// mouse does not override the refresh rate a game is pacing.
 const CURSOR_FRAME_NS: u64 = 16_666_667;
 
+/// How long a disabled wl_output stays bound before it is removed, so
+/// clients that were mid-bind are not killed by the removal.
+const GLOBAL_REMOVAL_DELAY: Duration = Duration::from_secs(5);
+
 type Allocator = GbmAllocator<DrmDeviceFd>;
 type Exporter = GbmFramebufferExporter<DrmDeviceFd>;
 type Manager = DrmOutputManager<Allocator, Exporter, (), DrmDeviceFd>;
@@ -64,11 +69,15 @@ pub struct Drm {
     nvidia: bool,
     frame_flags: FrameFlags,
     surfaces: HashMap<crtc::Handle, Surface>,
+    /// Connected connectors the scanner has already reported but that are
+    /// not lit, retried on the next scan.
+    failed: HashSet<connector::Handle>,
     pub devices: Devices,
 }
 
 struct Surface {
     output: Output,
+    global: GlobalId,
     id: OutputId,
     drm: Out,
     /// A frame is on its way to the screen and its vblank has not landed.
@@ -214,6 +223,7 @@ pub fn init(
                     s.redraw = true;
                 }
             }
+            scan(state);
             state.dirty.redraw = true;
         }
     })?;
@@ -227,7 +237,7 @@ pub fn init(
             && state
                 .backend
                 .drm()
-                .is_some_and(|d| d.node.dev_id() == device_id)
+                .is_some_and(|d| d.node.dev_id() == device_id && d.session.is_active())
         {
             scan(state);
         }
@@ -249,6 +259,7 @@ pub fn init(
             FrameFlags::DEFAULT
         },
         surfaces: HashMap::new(),
+        failed: HashSet::new(),
         devices: Devices::default(),
     }));
     scan(state);
@@ -267,21 +278,66 @@ fn scan(state: &mut State) {
             return;
         }
     };
+    let retry = std::mem::take(&mut drm.failed);
     for event in events {
         match event {
             DrmScanEvent::Connected {
                 connector,
                 crtc: Some(crtc),
             } => connect(state, connector, crtc),
+            DrmScanEvent::Connected {
+                connector,
+                crtc: None,
+            } => {
+                tracing::warn!(handle = ?connector.handle(), "no free crtc for the connector");
+                if let Some(drm) = state.backend.drm_mut() {
+                    drm.failed.insert(connector.handle());
+                }
+            }
             DrmScanEvent::Disconnected {
                 crtc: Some(crtc), ..
             } => disconnect(state, crtc),
+            DrmScanEvent::Changed {
+                connector,
+                crtc: Some(crtc),
+            } => {
+                disconnect(state, crtc);
+                connect(state, connector, crtc);
+            }
             _ => {}
         }
     }
+    for handle in retry {
+        retry_connector(state, handle);
+    }
     state.apply_layout();
 }
 
+/// Lights a connector that failed on an earlier scan, which the scanner
+/// will not report again until it changes.
+fn retry_connector(state: &mut State, handle: connector::Handle) {
+    let Some(drm) = state.backend.drm_mut() else {
+        return;
+    };
+    if drm.failed.contains(&handle) {
+        return;
+    }
+    let Some(info) = drm.scanner.connectors().get(&handle) else {
+        return;
+    };
+    if info.state() != connector::State::Connected {
+        return;
+    }
+    let info = info.clone();
+    let Some(crtc) = drm.scanner.crtc_for_connector(&handle) else {
+        drm.failed.insert(handle);
+        return;
+    };
+    if !drm.surfaces.contains_key(&crtc) {
+        connect(state, info, crtc);
+    }
+}
+
 fn connect(state: &mut State, connector: connector::Info, crtc: crtc::Handle) {
     let name = format!(
         "{}-{}",
@@ -312,6 +368,9 @@ fn connect(state: &mut State, connector: connector::Info, crtc: crtc::Handle) {
             .copied()
     }) else {
         tracing::warn!(name, "connector has no modes");
+        if let Some(drm) = state.backend.drm_mut() {
+            drm.failed.insert(connector.handle());
+        }
         return;
     };
     let transform = transform(config.transform);
@@ -352,7 +411,6 @@ fn connect(state: &mut State, connector: connector::Info, crtc: crtc::Handle) {
         Some(position),
     );
     output.set_preferred(wl_mode);
-    output.create_global::<State>(&core.display);
     let mut planes = drm.manager.device().planes(&crtc).ok();
     if drm.nvidia
         && let Some(p) = planes.as_mut()
@@ -372,6 +430,7 @@ fn connect(state: &mut State, connector: connector::Info, crtc: crtc::Handle) {
         Ok(out) => out,
         Err(e) => {
             tracing::warn!(name, "could not light up the output: {e}");
+            drm.failed.insert(connector.handle());
             return;
         }
     };
@@ -379,6 +438,7 @@ fn connect(state: &mut State, connector: connector::Info, crtc: crtc::Handle) {
         out.with_compositor(|c| c.vrr_supported(connector.handle())),
         Ok(VrrSupport::Supported)
     );
+    let global = output.create_global::<State>(&core.display);
     space.map_output(&output, position);
     let (w, h) = mode.size();
     let size = transform.transform_size(
@@ -406,6 +466,7 @@ fn connect(state: &mut State, connector: connector::Info, crtc: crtc::Handle) {
         crtc,
         Surface {
             output,
+            global,
             id,
             drm: out,
             queued: false,
@@ -540,8 +601,27 @@ fn disconnect(state: &mut State, crtc: crtc::Handle) {
         drm.handle.remove(token);
     }
     tracing::info!(name = surface.output.name(), "output disconnected");
+    state
+        .core
+        .display
+        .disable_global::<State>(surface.global.clone());
+    let global = surface.global.clone();
+    let removal = Timer::from_duration(GLOBAL_REMOVAL_DELAY);
+    let armed = drm.handle.insert_source(removal, move |_, _, state| {
+        state.core.display.remove_global::<State>(global.clone());
+        TimeoutAction::Drop
+    });
+    if let Err(e) = armed {
+        tracing::warn!("could not defer removing the wl_output: {e}");
+        state
+            .core
+            .display
+            .remove_global::<State>(surface.global.clone());
+    }
     state.wm.space.unmap_output(&surface.output);
     state.wm.layout.remove_output(surface.id);
+    state.close_layers(&surface.output);
+    state.services.lock.forget(&surface.output);
 }
 
 impl Drm {
@@ -769,9 +849,16 @@ fn draw(state: &mut State, crtc: crtc::Handle, target: u64) {
     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);
-    });
+    arm(
+        &drm.handle,
+        surface,
+        crtc,
+        wait,
+        preemptible,
+        move |state| {
+            schedule(state, crtc);
+        },
+    );
 }
 
 /// Renders every output that has something new and no frame in flight.

Modified file: crates/monolith/src/layers.rs+13 additions@@ -114,6 +114,19 @@ impl State {
         true
     }
 
+    /// Closes and unmaps every layer surface on an output that was unplugged.
+    pub fn close_layers(&mut self, output: &Output) {
+        let mut map = layer_map_for_output(output);
+        let layers: Vec<LayerSurface> = map.layers().cloned().collect();
+        for layer in layers {
+            layer.layer_surface().send_close();
+            map.unmap_layer(&layer);
+            if self.wm.layer_focus.as_ref() == Some(layer.wl_surface()) {
+                self.wm.layer_focus = None;
+            }
+        }
+    }
+
     /// Keeps tiled windows out of the space bars reserve.
     pub fn reserve_layers(&mut self) {
         let outputs: Vec<OutputId> = self.wm.layout.outputs().map(|(o, _)| o).collect();

Modified file: crates/monolith/src/lock.rs+6 additions@@ -39,6 +39,12 @@ impl Lock {
             .map(|(_, s)| s)
     }
 
+    /// Drops what belonged to an output that was unplugged.
+    pub fn forget(&mut self, output: &Output) {
+        self.surfaces.retain(|(o, _)| o != output);
+        self.blanked.remove(&output.name());
+    }
+
     /// Records a frame shown on `output`, which counts towards confirming a
     /// pending lock.
     pub fn shown(&mut self, output: &Output) {

monolith

Commit cac2b35598c9

Commit `cac2b35598c9`