monolith

public

Star0

Fork 0

Watch0

282 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `dbdff401f909`

tarball

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

7 files changed+1482-1411

drm: split into session, outputs, pacing, render and input modules

drm.rs had grown to 1400 lines with five unrelated concerns and a Surface lookup repeated nine times. The split follows the existing seams without changing behaviour, and surface_mut replaces the repeated backend.drm_mut().and_then(surfaces.get_mut) chains in the pacing timers.

Deleted file: crates/monolith/src/drm.rs−1411 deletions@@ -1,1411 +0,0 @@
-//! Bare metal. A libseat session, udev for the primary GPU and its
-//! connectors, libinput for input, and one smithay DRM output per connector,
-//! each rendered when its own vblank lands.
-
-use crate::backend::{Backend, logical_area};
-use crate::devices::Devices;
-use crate::input::Motion;
-use crate::scene::Draw;
-use crate::state::Services;
-use crate::state::{State, now_ns};
-use crate::wm::Wm;
-use monolith_config::{OutputTransform, Vrr};
-use monolith_layout::{OutputId, Rect};
-use smithay::backend::allocator::Fourcc;
-use smithay::backend::allocator::gbm::{GbmAllocator, GbmBufferFlags, GbmDevice};
-use smithay::backend::drm::VrrSupport;
-use smithay::backend::drm::compositor::{FrameFlags, PrimaryPlaneElement};
-use smithay::backend::drm::exporter::gbm::GbmFramebufferExporter;
-use smithay::backend::drm::output::{DrmOutput, DrmOutputManager, DrmOutputRenderElements};
-use smithay::backend::drm::{
-    DrmDevice, DrmDeviceFd, DrmEvent, DrmEventMetadata, DrmEventTime, DrmNode, NodeType,
-};
-use smithay::backend::input::{
-    AbsolutePositionEvent, Axis, AxisSource, Event, InputEvent, InputTime, KeyboardKeyEvent,
-    PointerAxisEvent, PointerButtonEvent, PointerMotionEvent,
-};
-use smithay::backend::libinput::{LibinputInputBackend, LibinputSessionInterface};
-use smithay::backend::session::libseat::LibSeatSession;
-use smithay::backend::session::{Event as SessionEvent, Session};
-use smithay::backend::udev::{UdevBackend, UdevEvent, all_gpus, primary_gpu};
-use smithay::input::pointer::AxisFrame;
-use smithay::output::{Mode, Output, PhysicalProperties, Scale, Subpixel};
-use smithay::reexports::calloop::timer::{TimeoutAction, Timer};
-use smithay::reexports::calloop::{EventLoop, LoopHandle, RegistrationToken};
-use smithay::reexports::drm::Device as _;
-use smithay::reexports::drm::control::{self, ModeTypeFlags, connector, crtc};
-use smithay::reexports::input::Libinput;
-use smithay::reexports::input::event::switch::{Switch, SwitchState};
-use smithay::reexports::rustix::fs::OFlags;
-use smithay::reexports::wayland_server::backend::GlobalId;
-use smithay::desktop::utils::OutputPresentationFeedback;
-use smithay::reexports::wayland_protocols::wp::presentation_time::server::wp_presentation_feedback::Kind;
-use smithay::utils::{DeviceFd, Logical, Monotonic, Point, Time, Transform};
-use smithay::wayland::presentation::Refresh;
-use smithay::wayland::drm_syncobj::{DrmSyncobjState, supports_syncobj_eventfd};
-use smithay_drm_extras::drm_scanner::{DrmScanEvent, DrmScanner};
-use std::collections::{HashMap, HashSet};
-use std::path::{Path, PathBuf};
-use std::time::Duration;
-
-use crate::frame::{CLEAR, FrameCtx};
-/// Frames that only move the cursor stay at or below 60 Hz under VRR, so the
-/// 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);
-
-/// Frames render without vblanks while retrying or looping on empty frames,
-/// and only a vblank drains the samples.
-const MAX_CPU_SAMPLES: usize = 1024;
-
-type Allocator = GbmAllocator<DrmDeviceFd>;
-type Exporter = GbmFramebufferExporter<DrmDeviceFd>;
-type Manager = DrmOutputManager<Allocator, Exporter, OutputPresentationFeedback, DrmDeviceFd>;
-type Out = DrmOutput<Allocator, Exporter, OutputPresentationFeedback, DrmDeviceFd>;
-
-pub struct Drm {
-    pub session: LibSeatSession,
-    libinput: Libinput,
-    handle: LoopHandle<'static, State>,
-    node: DrmNode,
-    pub render_node: DrmNode,
-    pub syncobj: Option<DrmSyncobjState>,
-    manager: Manager,
-    scanner: DrmScanner,
-    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.
-    queued: bool,
-    queued_at: u64,
-    /// The panel is lit. Off outputs are not rendered to.
-    powered: bool,
-    /// Out of the layout and Space, but still driven so it can relight.
-    parked: bool,
-    /// 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,
-    /// The pending render, timed to start just in time for `target_ns`.
-    scheduled: Option<RegistrationToken>,
-    /// `scheduled` only waits out a cap or a retry, so fresh content may
-    /// cancel it and draw at once.
-    preemptible: bool,
-    /// The vblank the frame being drawn or queued is meant for.
-    target_ns: Option<u64>,
-    budget: crate::pacing::Budget,
-    /// Frames presented since `stats_since`, for the once-a-second debug line.
-    presented: u32,
-    stats_since: u64,
-    vrr_capable: bool,
-    vrr_on: bool,
-    /// Only the cursor moved, which under VRR is drawn at a capped rate.
-    cursor_redraw: bool,
-    /// The last frame went straight to the primary plane without compositing.
-    scanout: bool,
-    /// Frames scanned out and per-frame compositor CPU times since
-    /// `stats_since`, for the targets in decisions.md.
-    scanned_out: u32,
-    frame_cpu_ns: Vec<u64>,
-}
-
-impl Surface {
-    /// The first vblank a render starting at `now` can still make, and the
-    /// latest moment to start it.
-    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
-/// first.
-pub fn primary() -> Result<PathBuf, Box<dyn std::error::Error>> {
-    let seat = std::env::var("XDG_SEAT").unwrap_or_else(|_| "seat0".into());
-    Ok(match primary_gpu(&seat)? {
-        Some(p) => p,
-        None => all_gpus(&seat)?.into_iter().next().ok_or("no GPU found")?,
-    })
-}
-
-pub fn init(
-    event_loop: &mut EventLoop<'static, State>,
-    state: &mut State,
-    path: &Path,
-) -> Result<(), Box<dyn std::error::Error>> {
-    let (mut session, notifier) = LibSeatSession::new()?;
-    let seat = session.seat();
-    let node = DrmNode::from_path(path)?;
-    tracing::info!(path = %path.display(), "primary GPU");
-    let fd = session.open(
-        path,
-        OFlags::RDWR | OFlags::CLOEXEC | OFlags::NOCTTY | OFlags::NONBLOCK,
-    )?;
-    let fd = DrmDeviceFd::new(DeviceFd::from(fd));
-    let (device, drm_events) = DrmDevice::new(fd.clone(), true)?;
-    let nvidia = device
-        .get_driver()
-        .map(|d| d.name().to_string_lossy().to_lowercase().contains("nvidia"))
-        .unwrap_or(false);
-    let syncobj = if supports_syncobj_eventfd(&fd) {
-        Some(DrmSyncobjState::new::<State>(
-            &state.core.display,
-            fd.clone(),
-        ))
-    } else {
-        tracing::info!("no syncobj eventfd support, clients stay on implicit sync");
-        None
-    };
-    let gbm = GbmDevice::new(fd)?;
-    let render_node = node
-        .node_with_type(NodeType::Render)
-        .and_then(Result::ok)
-        .unwrap_or(node);
-    let allocator = GbmAllocator::new(
-        gbm.clone(),
-        GbmBufferFlags::RENDERING | GbmBufferFlags::SCANOUT,
-    );
-    let exporter = GbmFramebufferExporter::new(gbm.clone(), render_node.into());
-    let render_formats: Vec<_> = state.renderer.render_formats().iter().copied().collect();
-    let manager = DrmOutputManager::new(
-        device,
-        allocator,
-        exporter,
-        Some(gbm),
-        [Fourcc::Xrgb8888, Fourcc::Argb8888],
-        render_formats,
-    );
-
-    let mut libinput =
-        Libinput::new_with_udev::<LibinputSessionInterface<LibSeatSession>>(session.clone().into());
-    libinput
-        .udev_assign_seat(&seat)
-        .map_err(|()| "libinput could not take the seat")?;
-    let handle = event_loop.handle();
-    handle.insert_source(
-        LibinputInputBackend::new(libinput.clone()),
-        |event, _, state| {
-            on_input(state, event);
-        },
-    )?;
-    handle.insert_source(notifier, |event, _, state| match event {
-        SessionEvent::PauseSession => {
-            if let Some(drm) = state.backend.drm_mut() {
-                drm.libinput.suspend();
-                drm.manager.pause();
-            }
-        }
-        SessionEvent::ActivateSession => {
-            if let Some(drm) = state.backend.drm_mut() {
-                if drm.libinput.resume().is_err() {
-                    tracing::warn!("libinput did not resume");
-                }
-                if let Err(e) = drm.manager.lock().activate(false) {
-                    tracing::warn!("could not reactivate the GPU: {e}");
-                }
-                for s in drm.surfaces.values_mut() {
-                    if let Some(token) = s.scheduled.take() {
-                        drm.handle.remove(token);
-                    }
-                    if let Err(e) = s.drm.frame_submitted() {
-                        tracing::warn!("could not drop the flip left over from the pause: {e}");
-                    }
-                    s.queued = false;
-                    s.last_vblank_ns = None;
-                    s.target_ns = None;
-                    s.failures = 0;
-                    s.redraw = true;
-                    if !s.powered
-                        && let Err(e) = s.drm.with_compositor(|c| c.clear())
-                    {
-                        tracing::warn!("could not keep the output off: {e}");
-                    }
-                }
-            }
-            scan(state);
-            state.dirty.redraw = true;
-        }
-    })?;
-    handle.insert_source(drm_events, |event, meta, state| match event {
-        DrmEvent::VBlank(crtc) => on_vblank(state, crtc, meta),
-        DrmEvent::Error(e) => tracing::warn!("drm: {e}"),
-    })?;
-    let udev = UdevBackend::new(&seat)?;
-    handle.insert_source(udev, move |event, _, state| {
-        if let UdevEvent::Changed { device_id } = event
-            && state
-                .backend
-                .drm()
-                .is_some_and(|d| d.node.dev_id() == device_id && d.session.is_active())
-        {
-            scan(state);
-        }
-    })?;
-
-    state.backend = Backend::Drm(Box::new(Drm {
-        session,
-        libinput,
-        handle,
-        node,
-        render_node,
-        syncobj,
-        manager,
-        scanner: DrmScanner::new(),
-        nvidia,
-        frame_flags: if std::env::var_os("MONOLITH_NO_SCANOUT").is_some() {
-            FrameFlags::empty()
-        } else {
-            FrameFlags::DEFAULT
-        },
-        surfaces: HashMap::new(),
-        failed: HashSet::new(),
-        devices: Devices::default(),
-    }));
-    scan(state);
-    Ok(())
-}
-
-/// Brings outputs in line with what is plugged in.
-fn scan(state: &mut State) {
-    let Some(drm) = state.backend.drm_mut() else {
-        return;
-    };
-    let events: Vec<DrmScanEvent> = match drm.scanner.scan_connectors(drm.manager.device()) {
-        Ok(result) => result.into_iter().collect(),
-        Err(e) => {
-            tracing::warn!("scanning connectors failed: {e}");
-            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),
-            } => changed(state, connector, crtc),
-            _ => {}
-        }
-    }
-    for handle in retry {
-        retry_connector(state, handle);
-    }
-    state.apply_power();
-    state.lid_act();
-    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 = connector_name(&connector);
-    let config = state
-        .settings
-        .config
-        .output
-        .named
-        .get(&name)
-        .cloned()
-        .unwrap_or_default();
-    let Some(mode) = choose_mode(&connector, &name, config.mode.as_deref()) 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);
-    let State {
-        backend: Backend::Drm(drm),
-        renderer,
-        wm: Wm { layout, space, .. },
-        core,
-        ..
-    } = state
-    else {
-        return;
-    };
-    let (mm_w, mm_h) = connector.size().unwrap_or((0, 0));
-    let output = Output::new(
-        name.clone(),
-        PhysicalProperties {
-            size: (mm_w as i32, mm_h as i32).into(),
-            subpixel: Subpixel::Unknown,
-            make: "Unknown".into(),
-            model: name.clone(),
-            serial_number: String::new(),
-        },
-    );
-    let wl_mode = Mode::from(mode);
-    let right = layout
-        .outputs()
-        .map(|(_, o)| o.area.right())
-        .fold(0.0, f64::max);
-    let position = match config.position {
-        Some([x, y]) => Point::from((x, y)),
-        None => Point::from((right.ceil() as i32, 0)),
-    };
-    let scale = config.scale();
-    output.change_current_state(
-        Some(wl_mode),
-        Some(transform),
-        Some(Scale::Fractional(scale)),
-        Some(position),
-    );
-    output.set_preferred(wl_mode);
-    let mut planes = drm.manager.device().planes(&crtc).ok();
-    if drm.nvidia
-        && let Some(p) = planes.as_mut()
-    {
-        // NVIDIA's overlay planes break composition, as anvil also found.
-        p.overlay.clear();
-    }
-    let out = match drm.manager.lock().initialize_output::<_, Draw>(
-        crtc,
-        mode,
-        &[connector.handle()],
-        &output,
-        planes,
-        renderer,
-        &DrmOutputRenderElements::default(),
-    ) {
-        Ok(out) => out,
-        Err(e) => {
-            tracing::warn!(name, "could not light up the output: {e}");
-            drm.failed.insert(connector.handle());
-            return;
-        }
-    };
-    let vrr_capable = matches!(
-        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 area = logical_area(position, wl_mode.size, transform, scale);
-    let id = layout.add_output(&name, area);
-    tracing::info!(
-        name,
-        w,
-        h,
-        scale,
-        refresh = mode.vrefresh(),
-        ?transform,
-        x = position.x,
-        y = position.y,
-        vrr_capable,
-        "output connected"
-    );
-    drm.surfaces.insert(
-        crtc,
-        Surface {
-            output,
-            global,
-            id,
-            drm: out,
-            queued: false,
-            queued_at: 0,
-            powered: true,
-            parked: false,
-            watchdog: None,
-            failures: 0,
-            redraw: true,
-            last_vblank_ns: None,
-            scheduled: None,
-            preemptible: false,
-            target_ns: None,
-            budget: crate::pacing::Budget::new(),
-            presented: 0,
-            stats_since: 0,
-            vrr_capable,
-            vrr_on: false,
-            cursor_redraw: false,
-            scanout: false,
-            scanned_out: 0,
-            frame_cpu_ns: Vec::new(),
-            refresh_ns: 1_000_000_000_000 / u64::from(wl_mode.refresh.max(1) as u32),
-        },
-    );
-}
-
-fn connector_name(connector: &connector::Info) -> String {
-    format!(
-        "{}-{}",
-        connector.interface().as_str(),
-        connector.interface_id()
-    )
-}
-
-/// The configured mode if the connector has it, else its preferred one.
-fn choose_mode(
-    connector: &connector::Info,
-    name: &str,
-    configured: Option<&str>,
-) -> Option<control::Mode> {
-    let chosen = configured.and_then(|spec| {
-        let found = pick_mode(connector.modes(), spec);
-        if found.is_none() {
-            tracing::warn!(name, spec, "no such mode, using the preferred one");
-        }
-        found
-    });
-    chosen.or_else(|| {
-        connector
-            .modes()
-            .iter()
-            .find(|m| m.mode_type().contains(ModeTypeFlags::PREFERRED))
-            .or_else(|| connector.modes().first())
-            .copied()
-    })
-}
-
-fn changed(state: &mut State, connector: connector::Info, crtc: crtc::Handle) {
-    if !remode(state, &connector, crtc) {
-        disconnect(state, crtc);
-        connect(state, connector, crtc);
-    }
-}
-
-/// Moves a lit output to the mode its connector now calls for without
-/// recreating the wl_output, so clients, windows, the lock surface and the
-/// power state stay as they are. False means the output has to be rebuilt.
-fn remode(state: &mut State, connector: &connector::Info, crtc: crtc::Handle) -> bool {
-    let name = connector_name(connector);
-    let State {
-        backend: Backend::Drm(drm),
-        renderer,
-        wm: Wm { layout, .. },
-        settings,
-        ..
-    } = state
-    else {
-        return false;
-    };
-    let Some(s) = drm.surfaces.get_mut(&crtc) else {
-        return false;
-    };
-    let (mm_w, mm_h) = connector.size().unwrap_or((0, 0));
-    if s.output.physical_properties().size != (mm_w as i32, mm_h as i32).into() {
-        return false;
-    }
-    let configured = settings.config.output.named.get(&name);
-    let Some(mode) = choose_mode(connector, &name, configured.and_then(|c| c.mode.as_deref()))
-    else {
-        return false;
-    };
-    let wl_mode = Mode::from(mode);
-    let moved = s.output.current_mode() != Some(wl_mode);
-    if moved {
-        let elements = DrmOutputRenderElements::default();
-        if let Err(e) = s.drm.use_mode::<_, Draw>(mode, renderer, &elements) {
-            tracing::warn!(name, "could not change the mode in place: {e}");
-            return false;
-        }
-        s.output
-            .change_current_state(Some(wl_mode), None, None, None);
-        s.refresh_ns = 1_000_000_000_000 / u64::from(wl_mode.refresh.max(1) as u32);
-        s.last_vblank_ns = None;
-        s.target_ns = None;
-        s.redraw = true;
-        let area = logical_area(
-            s.output.current_location(),
-            wl_mode.size,
-            s.output.current_transform(),
-            s.output.current_scale().fractional_scale(),
-        );
-        layout.set_output_area(s.id, area);
-        tracing::info!(
-            name,
-            w = wl_mode.size.w,
-            h = wl_mode.size.h,
-            refresh = mode.vrefresh(),
-            "output mode changed"
-        );
-    }
-    s.output.set_preferred(wl_mode);
-    if moved {
-        reconfigure_outputs(state);
-        state.reserve_layers();
-        state.reconfigure_lock();
-    }
-    true
-}
-
-/// The mode matching `WIDTHxHEIGHT` or `WIDTHxHEIGHT@HZ`, the highest rate
-/// when none is given and the nearest one when it is.
-fn pick_mode(modes: &[control::Mode], spec: &str) -> Option<control::Mode> {
-    let (size, rate) = match spec.split_once('@') {
-        Some((size, rate)) => (size, Some(rate.trim().parse::<f64>().ok()?)),
-        None => (spec, None),
-    };
-    let (w, h) = size.trim().split_once('x')?;
-    let size = (w.trim().parse::<u16>().ok()?, h.trim().parse::<u16>().ok()?);
-    let fitting = modes.iter().filter(|m| m.size() == size);
-    match rate {
-        Some(r) => fitting
-            .min_by(|a, b| {
-                let off = |m: &&control::Mode| (f64::from(m.vrefresh()) - r).abs();
-                off(a).total_cmp(&off(b))
-            })
-            .copied(),
-        None => fitting.max_by_key(|m| m.vrefresh()).copied(),
-    }
-}
-
-fn transform(t: OutputTransform) -> Transform {
-    match t {
-        OutputTransform::Normal => Transform::Normal,
-        OutputTransform::Rotate90 => Transform::_90,
-        OutputTransform::Rotate180 => Transform::_180,
-        OutputTransform::Rotate270 => Transform::_270,
-        OutputTransform::Flipped => Transform::Flipped,
-        OutputTransform::Flipped90 => Transform::Flipped90,
-        OutputTransform::Flipped180 => Transform::Flipped180,
-        OutputTransform::Flipped270 => Transform::Flipped270,
-    }
-}
-
-/// Outputs without a configured position are laid out left to right in
-/// their current order, so one rotating pushes its neighbours along.
-pub fn reconfigure_outputs(state: &mut State) {
-    let State {
-        backend: Backend::Drm(drm),
-        wm: Wm { layout, space, .. },
-        settings,
-        ..
-    } = state
-    else {
-        return;
-    };
-    let mut surfaces: Vec<&mut Surface> = drm.surfaces.values_mut().filter(|s| !s.parked).collect();
-    surfaces.sort_by_cached_key(|s| {
-        let name = s.output.name();
-        (
-            s.output.current_location().x,
-            !crate::power::internal(&name),
-        )
-    });
-    let mut right = 0;
-    let mut changed = false;
-    for s in surfaces {
-        let config = settings
-            .config
-            .output
-            .named
-            .get(&s.output.name())
-            .cloned()
-            .unwrap_or_default();
-        let Some(mode) = s.output.current_mode() else {
-            continue;
-        };
-        let transform = transform(config.transform);
-        let scale = config.scale();
-        let position: Point<i32, Logical> = match config.position {
-            Some([x, y]) => (x, y).into(),
-            None => (right, 0).into(),
-        };
-        let area = logical_area(position, mode.size, transform, scale);
-        right = right.max(area.right().ceil() as i32);
-        if s.output.current_transform() == transform
-            && s.output.current_location() == position
-            && s.output.current_scale().fractional_scale() == scale
-        {
-            continue;
-        }
-        s.output.change_current_state(
-            None,
-            Some(transform),
-            Some(Scale::Fractional(scale)),
-            Some(position),
-        );
-        space.map_output(&s.output, position);
-        layout.set_output_area(s.id, area);
-        s.redraw = true;
-        changed = true;
-        tracing::info!(
-            name = s.output.name(),
-            ?transform,
-            scale,
-            x = position.x,
-            y = position.y,
-            "output reconfigured"
-        );
-    }
-    if changed {
-        state.reserve_layers();
-        state.reconfigure_lock();
-        state.apply_layout();
-    }
-}
-
-fn disconnect(state: &mut State, crtc: crtc::Handle) {
-    let Some(drm) = state.backend.drm_mut() else {
-        return;
-    };
-    let Some(surface) = drm.surfaces.remove(&crtc) else {
-        return;
-    };
-    for token in [surface.scheduled, surface.watchdog].into_iter().flatten() {
-        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);
-    state.services.power.forget(&surface.output.name());
-    state.protocols.output_power.output_removed(&surface.output);
-}
-
-/// Takes the output called `name` out of the layout and Space, or puts it
-/// back. Its windows move to the other outputs and return when it does.
-pub fn set_parked(state: &mut State, name: &str, parked: bool) {
-    let State {
-        backend: Backend::Drm(drm),
-        wm: Wm { layout, space, .. },
-        ..
-    } = state
-    else {
-        return;
-    };
-    let Some(s) = drm.surfaces.values_mut().find(|s| s.output.name() == name) else {
-        return;
-    };
-    if s.parked == parked {
-        return;
-    }
-    s.parked = parked;
-    tracing::info!(name, parked, "output parked");
-    if parked {
-        space.unmap_output(&s.output);
-        layout.remove_output(s.id);
-    } else if let Some(mode) = s.output.current_mode() {
-        let position = s.output.current_location();
-        space.map_output(&s.output, position);
-        let scale = s.output.current_scale().fractional_scale();
-        let area = logical_area(position, mode.size, s.output.current_transform(), scale);
-        s.id = layout.add_output(name, area);
-        s.redraw = true;
-    }
-    let pos = state.input.pointer_pos;
-    let held = clamp(state, pos);
-    if held != pos {
-        state.warp_pointer(held, InputTime::now());
-    }
-    if !parked {
-        reconfigure_outputs(state);
-    }
-    state.reserve_layers();
-    state.reconfigure_lock();
-    state.apply_layout();
-}
-
-impl Drm {
-    pub fn names(&self) -> Vec<String> {
-        self.surfaces.values().map(|s| s.output.name()).collect()
-    }
-
-    /// Lights or darkens the output called `name`. Dark outputs get DPMS off
-    /// and no frames, and the next frame after turning on is a full modeset.
-    pub fn set_powered(&mut self, name: &str, on: bool) {
-        let active = self.session.is_active();
-        for s in self
-            .surfaces
-            .values_mut()
-            .filter(|s| s.output.name() == name)
-        {
-            if s.powered == on {
-                continue;
-            }
-            s.powered = on;
-            tracing::info!(name, on, "output power");
-            if on {
-                s.redraw = true;
-                s.last_vblank_ns = None;
-                continue;
-            }
-            for token in [s.scheduled.take(), s.watchdog.take()]
-                .into_iter()
-                .flatten()
-            {
-                self.handle.remove(token);
-            }
-            s.queued = false;
-            s.target_ns = None;
-            s.cursor_redraw = false;
-            if active && let Err(e) = s.drm.with_compositor(|c| c.clear()) {
-                tracing::warn!(name, "could not switch the output off: {e}");
-            }
-        }
-    }
-
-    pub fn output(&self, id: OutputId) -> Option<Output> {
-        self.surfaces
-            .values()
-            .find(|s| s.id == id)
-            .map(|s| s.output.clone())
-    }
-
-    pub fn timeline(&self, output: &Output) -> Option<crate::timing::Timeline> {
-        let s = self.surfaces.values().find(|s| s.output == *output)?;
-        Some(crate::timing::Timeline {
-            last: s.last_vblank_ns?,
-            refresh: if s.vrr_on { 0 } else { s.refresh_ns },
-            budget: s.budget.ns(),
-        })
-    }
-}
-
-fn on_vblank(state: &mut State, crtc: crtc::Handle, meta: &mut Option<DrmEventMetadata>) {
-    let presented = state
-        .backend
-        .drm()
-        .and_then(|d| d.surfaces.get(&crtc))
-        .map(|s| s.output.clone());
-    if let Some(output) = presented {
-        crate::fifo::presented(state, &output);
-    }
-    let Some(surface) = state
-        .backend
-        .drm_mut()
-        .and_then(|d| d.surfaces.get_mut(&crtc))
-    else {
-        return;
-    };
-    let feedback = surface.drm.frame_submitted().unwrap_or_else(|e| {
-        tracing::warn!("frame was not submitted: {e}");
-        None
-    });
-    surface.queued = false;
-    if let Err(e) = state.renderer.absorb_submit_stall() {
-        tracing::warn!("absorbing a submit stall failed: {e}");
-    }
-    let Some(surface) = state
-        .backend
-        .drm_mut()
-        .and_then(|d| d.surfaces.get_mut(&crtc))
-    else {
-        return;
-    };
-    if let Some(mut feedback) = feedback {
-        let (time, clock) = match meta.as_ref().map(|m| m.time) {
-            Some(DrmEventTime::Monotonic(t)) => (t, Kind::HwClock | Kind::HwCompletion),
-            _ => (Duration::from_nanos(now_ns()), Kind::empty()),
-        };
-        let refresh = Duration::from_nanos(surface.refresh_ns);
-        let refresh = if surface.vrr_on {
-            Refresh::variable(refresh)
-        } else {
-            Refresh::fixed(refresh)
-        };
-        let sequence = meta.as_ref().map_or(0, |m| u64::from(m.sequence));
-        feedback.presented(
-            Time::<Monotonic>::from(time),
-            refresh,
-            sequence,
-            Kind::Vsync | clock,
-        );
-    }
-    if let Some(DrmEventTime::Monotonic(t)) = meta.as_ref().map(|m| m.time) {
-        let t = t.as_nanos() as u64;
-        if let Some(target) = surface.target_ns.take() {
-            if t > target + surface.refresh_ns / 2 {
-                surface.budget.missed(surface.refresh_ns);
-                tracing::debug!(
-                    output = surface.output.name(),
-                    late_ns = t - target,
-                    budget_ns = surface.budget.ns(),
-                    "frame missed its vblank"
-                );
-            } else {
-                surface.budget.landed();
-            }
-        }
-        surface.last_vblank_ns = Some(t);
-        surface.presented += 1;
-        let window = t.saturating_sub(surface.stats_since);
-        if window >= 1_000_000_000 {
-            // Under VRR the panel waits for each flip, so the nominal refresh
-            // says nothing about how many vblanks there were.
-            let vblanks = (!surface.vrr_on).then(|| window / surface.refresh_ns.max(1));
-            let cpu = &mut surface.frame_cpu_ns;
-            cpu.sort_unstable();
-            let p99 = cpu.get(cpu.len().saturating_sub(1) * 99 / 100).copied();
-            tracing::debug!(
-                output = surface.output.name(),
-                presented = surface.presented,
-                vblanks,
-                vrr = surface.vrr_on,
-                scanned_out = surface.scanned_out,
-                cpu_p99_us = p99.map(|ns| ns / 1000),
-                budget_us = surface.budget.ns() / 1000,
-                "frame rate"
-            );
-            cpu.clear();
-            surface.scanned_out = 0;
-            surface.presented = 0;
-            surface.stats_since = t;
-        }
-    }
-    if surface.redraw || surface.cursor_redraw {
-        schedule(state, crtc);
-    }
-}
-
-/// Starts a render at the last moment that still makes the next reachable
-/// vblank, so commits arriving until then make it into the frame.
-fn schedule(state: &mut State, crtc: crtc::Handle) {
-    let Some(drm) = state.backend.drm_mut() else {
-        return;
-    };
-    if !drm.session.is_active() {
-        return;
-    }
-    let Some(surface) = drm.surfaces.get_mut(&crtc) else {
-        return;
-    };
-    if !surface.powered || surface.queued || surface.scheduled.is_some() {
-        return;
-    }
-    let now = now_ns();
-    if surface.vrr_on {
-        let since_flip = surface
-            .last_vblank_ns
-            .map_or(u64::MAX, |l| now.saturating_sub(l));
-        if surface.redraw || since_flip >= CURSOR_FRAME_NS {
-            draw(state, crtc, now);
-            return;
-        }
-        let wait = Duration::from_nanos(CURSOR_FRAME_NS - since_flip);
-        arm(&drm.handle, surface, crtc, wait, true, move |state| {
-            draw(state, crtc, now_ns());
-        });
-        return;
-    }
-    let Some((vblank, start)) = surface.next_deadline(now) else {
-        draw(state, crtc, now);
-        return;
-    };
-    surface.target_ns = Some(vblank);
-    let wait = Duration::from_nanos(start.saturating_sub(now));
-    arm(&drm.handle, surface, crtc, wait, false, move |state| {
-        let target = state
-            .backend
-            .drm()
-            .and_then(|d| d.surfaces.get(&crtc)?.target_ns);
-        if let Some(target) = target {
-            draw(state, crtc, target);
-        }
-    });
-}
-
-/// Runs `fire` once after `after`, tracked in `surface.scheduled` until then.
-fn arm(
-    handle: &LoopHandle<'static, State>,
-    surface: &mut Surface,
-    crtc: crtc::Handle,
-    after: Duration,
-    preemptible: bool,
-    mut fire: impl FnMut(&mut State) + 'static,
-) {
-    let token = handle.insert_source(Timer::from_duration(after), move |_, _, state| {
-        if let Some(s) = state
-            .backend
-            .drm_mut()
-            .and_then(|d| d.surfaces.get_mut(&crtc))
-        {
-            s.scheduled = None;
-        }
-        fire(state);
-        TimeoutAction::Drop
-    });
-    match token {
-        Ok(token) => {
-            surface.scheduled = Some(token);
-            surface.preemptible = preemptible;
-        }
-        Err(e) => tracing::warn!(
-            output = surface.output.name(),
-            "could not arm a render timer: {e}"
-        ),
-    }
-}
-
-/// 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
-/// try waits a refresh.
-fn draw(state: &mut State, crtc: crtc::Handle, target: u64) {
-    if !render_surface(state, crtc, target) {
-        return;
-    }
-    let Some(drm) = state.backend.drm_mut() else {
-        return;
-    };
-    let Some(surface) = drm.surfaces.get_mut(&crtc) else {
-        return;
-    };
-    if surface.scheduled.is_some() {
-        return;
-    }
-    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);
-        },
-    );
-}
-
-/// Renders every output that has something new and no frame in flight.
-pub fn render(state: &mut State) {
-    let Some(drm) = state.backend.drm_mut() else {
-        return;
-    };
-    let cursor = std::mem::take(&mut state.dirty.cursor);
-    let all = std::mem::take(&mut state.dirty.redraw);
-    for s in drm.surfaces.values_mut() {
-        s.redraw |= all;
-        s.cursor_redraw |= cursor;
-        if all
-            && s.preemptible
-            && let Some(token) = s.scheduled.take()
-        {
-            drm.handle.remove(token);
-        }
-    }
-    let ready: Vec<crtc::Handle> = drm
-        .surfaces
-        .iter()
-        .filter(|(_, s)| (s.redraw || s.cursor_redraw) && !s.queued)
-        .map(|(c, _)| *c)
-        .collect();
-    for crtc in ready {
-        schedule(state, crtc);
-    }
-}
-
-/// Draws one output for the vblank at `target`. Returns whether it still
-/// animates without a frame in flight, and so needs another render.
-#[profiling::function]
-fn render_surface(state: &mut State, crtc: crtc::Handle, target: u64) -> bool {
-    let State {
-        backend: Backend::Drm(drm),
-        renderer,
-        wm,
-        settings,
-        core,
-        input,
-        services:
-            Services {
-                lock,
-                captures,
-                xwayland,
-                ..
-            },
-        ..
-    } = state
-    else {
-        return false;
-    };
-    if !drm.session.is_active() {
-        return false;
-    }
-    let Some(surface) = drm.surfaces.get_mut(&crtc) else {
-        return false;
-    };
-    if surface.queued || !surface.powered {
-        return false;
-    }
-    surface.cursor_redraw = false;
-    let shown = crate::frame::shown_windows(wm, surface.id, &surface.output, target);
-    let fullscreen = shown.fullscreen;
-    let forced = fullscreen.and_then(|w| wm.get(w)?.rule.vrr);
-    let want_vrr = surface.vrr_capable
-        && forced.unwrap_or(match settings.config.output.vrr {
-            Vrr::Off => false,
-            Vrr::On => true,
-            Vrr::Fullscreen => fullscreen.is_some(),
-        });
-    if want_vrr != surface.vrr_on {
-        match surface.drm.with_compositor(|c| c.use_vrr(want_vrr)) {
-            Ok(()) => {
-                surface.vrr_on = want_vrr;
-                tracing::info!(
-                    output = surface.output.name(),
-                    vrr = want_vrr,
-                    "adaptive sync"
-                );
-            }
-            Err(e) => {
-                tracing::warn!("could not switch adaptive sync: {e}");
-                surface.vrr_capable = false;
-            }
-        }
-    }
-    let began = std::time::Instant::now();
-    let frame_cpu_began = thread_cpu_ns();
-    let now = target;
-    if wm.layout.output(surface.id).is_none() {
-        return false;
-    }
-    let scene_began = std::time::Instant::now();
-    let ctx = FrameCtx {
-        renderer: &mut *renderer,
-        wm: &mut *wm,
-        input: &mut *input,
-        lock: &*lock,
-        deco: &settings.config.decoration,
-        unmanaged: xwayland.as_ref().map_or(&[], |x| &x.unmanaged),
-    };
-    let elements = crate::frame::compose(ctx, surface.id, &surface.output, now, true);
-    let scene_ns = scene_began.elapsed().as_nanos() as u64;
-    let animating = wm.anim.active(now);
-    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)
-    {
-        Ok(result) if !result.is_empty => {
-            let direct = matches!(result.primary_element, PrimaryPlaneElement::Element(_));
-            let feedback = crate::frame::take_presentation_feedback(
-                wm,
-                lock,
-                xwayland.as_ref().map_or(&[], |x| &x.unmanaged),
-                &shown,
-                &surface.output,
-                &result.states,
-            );
-            if direct {
-                surface.scanned_out += 1;
-            }
-            if direct != surface.scanout {
-                surface.scanout = direct;
-                tracing::info!(
-                    output = surface.output.name(),
-                    scanout = direct,
-                    elements = elements.len(),
-                    overlay_planes = result.overlay_elements.len(),
-                    cursor_plane = result.cursor_element.is_some(),
-                    "direct scanout"
-                );
-            }
-            let queue_began = std::time::Instant::now();
-            match surface.drm.queue_frame(feedback) {
-                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) => {
-                    failed = true;
-                    tracing::warn!("queueing a frame failed: {e}");
-                }
-            }
-            queue_ns = queue_began.elapsed().as_nanos() as u64;
-        }
-        Ok(result) => {
-            drop(crate::frame::take_presentation_feedback(
-                wm,
-                lock,
-                xwayland.as_ref().map_or(&[], |x| &x.unmanaged),
-                &shown,
-                &surface.output,
-                &result.states,
-            ));
-            lock.shown(&surface.output);
-        }
-        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;
-    let took = began.elapsed().as_nanos() as u64;
-    surface.budget.record(took);
-    if surface.frame_cpu_ns.len() < MAX_CPU_SAMPLES {
-        surface.frame_cpu_ns.push(thread_cpu_ns() - frame_cpu_began);
-    }
-    if took > surface.refresh_ns / 2 {
-        tracing::debug!(
-            output = surface.output.name(),
-            took_ns = took,
-            scene_ns,
-            render_ns,
-            render_cpu_ns,
-            queue_ns,
-            "slow frame"
-        );
-    }
-    if !surface.queued {
-        surface.target_ns = None;
-    }
-    surface.failures = if failed { surface.failures + 1 } else { 0 };
-    surface.redraw = animating || failed;
-    if !surface.queued {
-        crate::fifo::release_idle(&core.handle, &surface.output);
-    }
-    let elapsed = core.start.elapsed();
-    crate::frame::send_frame_callbacks(
-        wm,
-        lock,
-        xwayland.as_ref().map_or(&[], |x| &x.unmanaged),
-        &shown,
-        &surface.output,
-        elapsed,
-        input.dnd_icon.as_ref(),
-    );
-    crate::frame::send_cursor_frames(wm, input, surface.id, &surface.output, elapsed);
-    (animating || failed) && !surface.queued
-}
-
-/// CPU time this thread has used, to tell a render that works from one that
-/// waits or is descheduled.
-fn thread_cpu_ns() -> u64 {
-    let t = smithay::reexports::rustix::time::clock_gettime(
-        smithay::reexports::rustix::time::ClockId::ThreadCPUTime,
-    );
-    t.tv_sec as u64 * 1_000_000_000 + t.tv_nsec as u64
-}
-
-fn on_input(state: &mut State, event: InputEvent<LibinputInputBackend>) {
-    match event {
-        InputEvent::Keyboard { event } => {
-            let time = event.time();
-            state.key(event.key_code(), event.state(), time);
-        }
-        InputEvent::PointerMotion { event } => {
-            let (delta, unaccel) = (event.delta(), event.delta_unaccel());
-            let pos = clamp(state, state.input.pointer_pos + delta);
-            state.pointer_motion(pos, Motion::Relative { delta, unaccel }, event.time());
-            state.pointer_frame();
-            state.dirty.cursor = true;
-        }
-        InputEvent::PointerMotionAbsolute { event } => {
-            // Tablets and absolute mice span the whole desktop, as in sway.
-            let Some(area) = state
-                .wm
-                .layout
-                .outputs()
-                .map(|(_, o)| o.area)
-                .reduce(|a, b| a.union(&b))
-            else {
-                return;
-            };
-            let p = event.position_transformed((area.w as i32, area.h as i32).into());
-            let pos = clamp(state, Point::from((area.x + p.x, area.y + p.y)));
-            state.pointer_motion(pos, Motion::Absolute, event.time());
-            state.pointer_frame();
-            state.dirty.cursor = true;
-        }
-        InputEvent::PointerButton { event } => {
-            let time = event.time();
-            state.pointer_button(event.button_code(), event.state(), time);
-            state.pointer_frame();
-        }
-        InputEvent::PointerAxis { event } => {
-            let factor = state
-                .backend
-                .drm()
-                .map_or(1.0, |d| d.devices.scroll_factor(&event.device()));
-            let source = event.source();
-            let mut frame = AxisFrame::new(event.time()).source(source);
-            for axis in [Axis::Horizontal, Axis::Vertical] {
-                let v120 = event.amount_v120(axis).map(|v| v * factor);
-                if let Some(v120) = v120 {
-                    frame = frame.v120(axis, v120 as i32);
-                }
-                let amount = event
-                    .amount(axis)
-                    .map(|a| a * factor)
-                    .or_else(|| v120.map(|v| v * 15.0 / 120.0));
-                match amount {
-                    Some(a) if a != 0.0 => frame = frame.value(axis, a),
-                    Some(_) if source == AxisSource::Finger => frame = frame.stop(axis),
-                    _ => {}
-                }
-            }
-            state.pointer_axis(frame);
-            state.pointer_frame();
-        }
-        InputEvent::SwitchToggle { event } => {
-            if event.switch() == Some(Switch::Lid) {
-                state.lid_changed(event.switch_state() == SwitchState::On);
-            }
-        }
-        InputEvent::DeviceAdded { device } => {
-            if let Some(drm) = state.backend.drm_mut() {
-                drm.devices.add(device, &state.settings.config.input);
-            }
-        }
-        InputEvent::DeviceRemoved { device } => {
-            if let Some(drm) = state.backend.drm_mut() {
-                drm.devices.remove(&device);
-            }
-        }
-        _ => {}
-    }
-}
-
-/// Keeps the pointer on some output, sliding along the edge it hit.
-fn clamp(
-    state: &State,
-    pos: Point<f64, smithay::utils::Logical>,
-) -> Point<f64, smithay::utils::Logical> {
-    let inside = |a: &Rect, p: Point<f64, smithay::utils::Logical>| a.contains(p.x, p.y);
-    let areas: Vec<Rect> = state.wm.layout.outputs().map(|(_, o)| o.area).collect();
-    if areas.iter().any(|a| inside(a, pos)) {
-        return pos;
-    }
-    let Some(a) = areas
-        .iter()
-        .find(|a| inside(a, state.input.pointer_pos))
-        .or(areas.first())
-    else {
-        return pos;
-    };
-    Point::from((
-        pos.x.clamp(a.x, a.right() - 1.0),
-        pos.y.clamp(a.y, a.bottom() - 1.0),
-    ))
-}

Added file: crates/monolith/src/drm/input.rs+115 additions@@ -0,0 +1,115 @@
+//! libinput events turned into compositor input.
+
+use crate::input::Motion;
+use crate::state::State;
+use monolith_layout::Rect;
+use smithay::backend::input::{
+    AbsolutePositionEvent, Axis, AxisSource, Event, InputEvent, KeyboardKeyEvent, PointerAxisEvent,
+    PointerButtonEvent, PointerMotionEvent,
+};
+use smithay::backend::libinput::LibinputInputBackend;
+use smithay::input::pointer::AxisFrame;
+use smithay::reexports::input::event::switch::{Switch, SwitchState};
+use smithay::utils::Point;
+
+pub(super) fn on_input(state: &mut State, event: InputEvent<LibinputInputBackend>) {
+    match event {
+        InputEvent::Keyboard { event } => {
+            let time = event.time();
+            state.key(event.key_code(), event.state(), time);
+        }
+        InputEvent::PointerMotion { event } => {
+            let (delta, unaccel) = (event.delta(), event.delta_unaccel());
+            let pos = clamp(state, state.input.pointer_pos + delta);
+            state.pointer_motion(pos, Motion::Relative { delta, unaccel }, event.time());
+            state.pointer_frame();
+            state.dirty.cursor = true;
+        }
+        InputEvent::PointerMotionAbsolute { event } => {
+            // Tablets and absolute mice span the whole desktop, as in sway.
+            let Some(area) = state
+                .wm
+                .layout
+                .outputs()
+                .map(|(_, o)| o.area)
+                .reduce(|a, b| a.union(&b))
+            else {
+                return;
+            };
+            let p = event.position_transformed((area.w as i32, area.h as i32).into());
+            let pos = clamp(state, Point::from((area.x + p.x, area.y + p.y)));
+            state.pointer_motion(pos, Motion::Absolute, event.time());
+            state.pointer_frame();
+            state.dirty.cursor = true;
+        }
+        InputEvent::PointerButton { event } => {
+            let time = event.time();
+            state.pointer_button(event.button_code(), event.state(), time);
+            state.pointer_frame();
+        }
+        InputEvent::PointerAxis { event } => {
+            let factor = state
+                .backend
+                .drm()
+                .map_or(1.0, |d| d.devices.scroll_factor(&event.device()));
+            let source = event.source();
+            let mut frame = AxisFrame::new(event.time()).source(source);
+            for axis in [Axis::Horizontal, Axis::Vertical] {
+                let v120 = event.amount_v120(axis).map(|v| v * factor);
+                if let Some(v120) = v120 {
+                    frame = frame.v120(axis, v120 as i32);
+                }
+                let amount = event
+                    .amount(axis)
+                    .map(|a| a * factor)
+                    .or_else(|| v120.map(|v| v * 15.0 / 120.0));
+                match amount {
+                    Some(a) if a != 0.0 => frame = frame.value(axis, a),
+                    Some(_) if source == AxisSource::Finger => frame = frame.stop(axis),
+                    _ => {}
+                }
+            }
+            state.pointer_axis(frame);
+            state.pointer_frame();
+        }
+        InputEvent::SwitchToggle { event } => {
+            if event.switch() == Some(Switch::Lid) {
+                state.lid_changed(event.switch_state() == SwitchState::On);
+            }
+        }
+        InputEvent::DeviceAdded { device } => {
+            if let Some(drm) = state.backend.drm_mut() {
+                drm.devices.add(device, &state.settings.config.input);
+            }
+        }
+        InputEvent::DeviceRemoved { device } => {
+            if let Some(drm) = state.backend.drm_mut() {
+                drm.devices.remove(&device);
+            }
+        }
+        _ => {}
+    }
+}
+
+/// Keeps the pointer on some output, sliding along the edge it hit.
+pub(super) fn clamp(
+    state: &State,
+    pos: Point<f64, smithay::utils::Logical>,
+) -> Point<f64, smithay::utils::Logical> {
+    let inside = |a: &Rect, p: Point<f64, smithay::utils::Logical>| a.contains(p.x, p.y);
+    let areas: Vec<Rect> = state.wm.layout.outputs().map(|(_, o)| o.area).collect();
+    if areas.iter().any(|a| inside(a, pos)) {
+        return pos;
+    }
+    let Some(a) = areas
+        .iter()
+        .find(|a| inside(a, state.input.pointer_pos))
+        .or(areas.first())
+    else {
+        return pos;
+    };
+    Point::from((
+        pos.x.clamp(a.x, a.right() - 1.0),
+        pos.y.clamp(a.y, a.bottom() - 1.0),
+    ))
+}

Added file: crates/monolith/src/drm/mod.rs+172 additions@@ -0,0 +1,172 @@
+//! Bare metal. A libseat session, udev for the primary GPU and its
+//! connectors, libinput for input, and one smithay DRM output per connector,
+//! each rendered when its own vblank lands.
+
+mod input;
+mod outputs;
+mod pacing;
+mod render;
+mod session;
+
+pub use outputs::{reconfigure_outputs, set_parked};
+pub use render::render;
+pub use session::{init, primary};
+
+use crate::devices::Devices;
+use crate::state::State;
+use monolith_layout::OutputId;
+use smithay::backend::allocator::gbm::GbmAllocator;
+use smithay::backend::drm::compositor::FrameFlags;
+use smithay::backend::drm::exporter::gbm::GbmFramebufferExporter;
+use smithay::backend::drm::output::{DrmOutput, DrmOutputManager};
+use smithay::backend::drm::{DrmDeviceFd, DrmNode};
+use smithay::backend::session::Session;
+use smithay::backend::session::libseat::LibSeatSession;
+use smithay::desktop::utils::OutputPresentationFeedback;
+use smithay::output::Output;
+use smithay::reexports::calloop::{LoopHandle, RegistrationToken};
+use smithay::reexports::drm::control::{connector, crtc};
+use smithay::reexports::input::Libinput;
+use smithay::reexports::wayland_server::backend::GlobalId;
+use smithay::wayland::drm_syncobj::DrmSyncobjState;
+use smithay_drm_extras::drm_scanner::DrmScanner;
+use std::collections::{HashMap, HashSet};
+
+type Allocator = GbmAllocator<DrmDeviceFd>;
+type Exporter = GbmFramebufferExporter<DrmDeviceFd>;
+type Manager = DrmOutputManager<Allocator, Exporter, OutputPresentationFeedback, DrmDeviceFd>;
+type Out = DrmOutput<Allocator, Exporter, OutputPresentationFeedback, DrmDeviceFd>;
+
+pub struct Drm {
+    pub session: LibSeatSession,
+    libinput: Libinput,
+    handle: LoopHandle<'static, State>,
+    node: DrmNode,
+    pub render_node: DrmNode,
+    pub syncobj: Option<DrmSyncobjState>,
+    manager: Manager,
+    scanner: DrmScanner,
+    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.
+    queued: bool,
+    queued_at: u64,
+    /// The panel is lit. Off outputs are not rendered to.
+    powered: bool,
+    /// Out of the layout and Space, but still driven so it can relight.
+    parked: bool,
+    /// 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,
+    /// The pending render, timed to start just in time for `target_ns`.
+    scheduled: Option<RegistrationToken>,
+    /// `scheduled` only waits out a cap or a retry, so fresh content may
+    /// cancel it and draw at once.
+    preemptible: bool,
+    /// The vblank the frame being drawn or queued is meant for.
+    target_ns: Option<u64>,
+    budget: crate::pacing::Budget,
+    /// Frames presented since `stats_since`, for the once-a-second debug line.
+    presented: u32,
+    stats_since: u64,
+    vrr_capable: bool,
+    vrr_on: bool,
+    /// Only the cursor moved, which under VRR is drawn at a capped rate.
+    cursor_redraw: bool,
+    /// The last frame went straight to the primary plane without compositing.
+    scanout: bool,
+    /// Frames scanned out and per-frame compositor CPU times since
+    /// `stats_since`, for the targets in decisions.md.
+    scanned_out: u32,
+    frame_cpu_ns: Vec<u64>,
+}
+
+fn surface_mut(state: &mut State, crtc: crtc::Handle) -> Option<&mut Surface> {
+    state.backend.drm_mut()?.surfaces.get_mut(&crtc)
+}
+
+impl Surface {
+    /// The first vblank a render starting at `now` can still make, and the
+    /// latest moment to start it.
+    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)
+    }
+}
+
+impl Drm {
+    pub fn names(&self) -> Vec<String> {
+        self.surfaces.values().map(|s| s.output.name()).collect()
+    }
+
+    /// Lights or darkens the output called `name`. Dark outputs get DPMS off
+    /// and no frames, and the next frame after turning on is a full modeset.
+    pub fn set_powered(&mut self, name: &str, on: bool) {
+        let active = self.session.is_active();
+        for s in self
+            .surfaces
+            .values_mut()
+            .filter(|s| s.output.name() == name)
+        {
+            if s.powered == on {
+                continue;
+            }
+            s.powered = on;
+            tracing::info!(name, on, "output power");
+            if on {
+                s.redraw = true;
+                s.last_vblank_ns = None;
+                continue;
+            }
+            for token in [s.scheduled.take(), s.watchdog.take()]
+                .into_iter()
+                .flatten()
+            {
+                self.handle.remove(token);
+            }
+            s.queued = false;
+            s.target_ns = None;
+            s.cursor_redraw = false;
+            if active && let Err(e) = s.drm.with_compositor(|c| c.clear()) {
+                tracing::warn!(name, "could not switch the output off: {e}");
+            }
+        }
+    }
+
+    pub fn output(&self, id: OutputId) -> Option<Output> {
+        self.surfaces
+            .values()
+            .find(|s| s.id == id)
+            .map(|s| s.output.clone())
+    }
+
+    pub fn timeline(&self, output: &Output) -> Option<crate::timing::Timeline> {
+        let s = self.surfaces.values().find(|s| s.output == *output)?;
+        Some(crate::timing::Timeline {
+            last: s.last_vblank_ns?,
+            refresh: if s.vrr_on { 0 } else { s.refresh_ns },
+            budget: s.budget.ns(),
+        })
+    }
+}

Added file: crates/monolith/src/drm/outputs.rs+514 additions@@ -0,0 +1,514 @@
+//! Connectors turning into outputs, and back.
+
+use super::Surface;
+use super::input::clamp;
+use crate::backend::{Backend, logical_area};
+use crate::scene::Draw;
+use crate::state::State;
+use crate::wm::Wm;
+use monolith_config::OutputTransform;
+use smithay::backend::drm::VrrSupport;
+use smithay::backend::drm::output::DrmOutputRenderElements;
+use smithay::backend::input::InputTime;
+use smithay::output::{Mode, Output, PhysicalProperties, Scale, Subpixel};
+use smithay::reexports::calloop::timer::{TimeoutAction, Timer};
+use smithay::reexports::drm::control::{self, ModeTypeFlags, connector, crtc};
+use smithay::utils::{Logical, Point, Transform};
+use smithay_drm_extras::drm_scanner::DrmScanEvent;
+use std::time::Duration;
+
+/// 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);
+
+/// Brings outputs in line with what is plugged in.
+pub(super) fn scan(state: &mut State) {
+    let Some(drm) = state.backend.drm_mut() else {
+        return;
+    };
+    let events: Vec<DrmScanEvent> = match drm.scanner.scan_connectors(drm.manager.device()) {
+        Ok(result) => result.into_iter().collect(),
+        Err(e) => {
+            tracing::warn!("scanning connectors failed: {e}");
+            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),
+            } => changed(state, connector, crtc),
+            _ => {}
+        }
+    }
+    for handle in retry {
+        retry_connector(state, handle);
+    }
+    state.apply_power();
+    state.lid_act();
+    state.apply_layout();
+}
+
+/// Lights a connector that failed on an earlier scan, which the scanner
+/// will not report again until it changes.
+pub(super) 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);
+    }
+}
+
+pub(super) fn connect(state: &mut State, connector: connector::Info, crtc: crtc::Handle) {
+    let name = connector_name(&connector);
+    let config = state
+        .settings
+        .config
+        .output
+        .named
+        .get(&name)
+        .cloned()
+        .unwrap_or_default();
+    let Some(mode) = choose_mode(&connector, &name, config.mode.as_deref()) 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);
+    let State {
+        backend: Backend::Drm(drm),
+        renderer,
+        wm: Wm { layout, space, .. },
+        core,
+        ..
+    } = state
+    else {
+        return;
+    };
+    let (mm_w, mm_h) = connector.size().unwrap_or((0, 0));
+    let output = Output::new(
+        name.clone(),
+        PhysicalProperties {
+            size: (mm_w as i32, mm_h as i32).into(),
+            subpixel: Subpixel::Unknown,
+            make: "Unknown".into(),
+            model: name.clone(),
+            serial_number: String::new(),
+        },
+    );
+    let wl_mode = Mode::from(mode);
+    let right = layout
+        .outputs()
+        .map(|(_, o)| o.area.right())
+        .fold(0.0, f64::max);
+    let position = match config.position {
+        Some([x, y]) => Point::from((x, y)),
+        None => Point::from((right.ceil() as i32, 0)),
+    };
+    let scale = config.scale();
+    output.change_current_state(
+        Some(wl_mode),
+        Some(transform),
+        Some(Scale::Fractional(scale)),
+        Some(position),
+    );
+    output.set_preferred(wl_mode);
+    let mut planes = drm.manager.device().planes(&crtc).ok();
+    if drm.nvidia
+        && let Some(p) = planes.as_mut()
+    {
+        // NVIDIA's overlay planes break composition, as anvil also found.
+        p.overlay.clear();
+    }
+    let out = match drm.manager.lock().initialize_output::<_, Draw>(
+        crtc,
+        mode,
+        &[connector.handle()],
+        &output,
+        planes,
+        renderer,
+        &DrmOutputRenderElements::default(),
+    ) {
+        Ok(out) => out,
+        Err(e) => {
+            tracing::warn!(name, "could not light up the output: {e}");
+            drm.failed.insert(connector.handle());
+            return;
+        }
+    };
+    let vrr_capable = matches!(
+        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 area = logical_area(position, wl_mode.size, transform, scale);
+    let id = layout.add_output(&name, area);
+    tracing::info!(
+        name,
+        w,
+        h,
+        scale,
+        refresh = mode.vrefresh(),
+        ?transform,
+        x = position.x,
+        y = position.y,
+        vrr_capable,
+        "output connected"
+    );
+    drm.surfaces.insert(
+        crtc,
+        Surface {
+            output,
+            global,
+            id,
+            drm: out,
+            queued: false,
+            queued_at: 0,
+            powered: true,
+            parked: false,
+            watchdog: None,
+            failures: 0,
+            redraw: true,
+            last_vblank_ns: None,
+            scheduled: None,
+            preemptible: false,
+            target_ns: None,
+            budget: crate::pacing::Budget::new(),
+            presented: 0,
+            stats_since: 0,
+            vrr_capable,
+            vrr_on: false,
+            cursor_redraw: false,
+            scanout: false,
+            scanned_out: 0,
+            frame_cpu_ns: Vec::new(),
+            refresh_ns: 1_000_000_000_000 / u64::from(wl_mode.refresh.max(1) as u32),
+        },
+    );
+}
+
+pub(super) fn connector_name(connector: &connector::Info) -> String {
+    format!(
+        "{}-{}",
+        connector.interface().as_str(),
+        connector.interface_id()
+    )
+}
+
+/// The configured mode if the connector has it, else its preferred one.
+pub(super) fn choose_mode(
+    connector: &connector::Info,
+    name: &str,
+    configured: Option<&str>,
+) -> Option<control::Mode> {
+    let chosen = configured.and_then(|spec| {
+        let found = pick_mode(connector.modes(), spec);
+        if found.is_none() {
+            tracing::warn!(name, spec, "no such mode, using the preferred one");
+        }
+        found
+    });
+    chosen.or_else(|| {
+        connector
+            .modes()
+            .iter()
+            .find(|m| m.mode_type().contains(ModeTypeFlags::PREFERRED))
+            .or_else(|| connector.modes().first())
+            .copied()
+    })
+}
+
+pub(super) fn changed(state: &mut State, connector: connector::Info, crtc: crtc::Handle) {
+    if !remode(state, &connector, crtc) {
+        disconnect(state, crtc);
+        connect(state, connector, crtc);
+    }
+}
+
+/// Moves a lit output to the mode its connector now calls for without
+/// recreating the wl_output, so clients, windows, the lock surface and the
+/// power state stay as they are. False means the output has to be rebuilt.
+pub(super) fn remode(state: &mut State, connector: &connector::Info, crtc: crtc::Handle) -> bool {
+    let name = connector_name(connector);
+    let State {
+        backend: Backend::Drm(drm),
+        renderer,
+        wm: Wm { layout, .. },
+        settings,
+        ..
+    } = state
+    else {
+        return false;
+    };
+    let Some(s) = drm.surfaces.get_mut(&crtc) else {
+        return false;
+    };
+    let (mm_w, mm_h) = connector.size().unwrap_or((0, 0));
+    if s.output.physical_properties().size != (mm_w as i32, mm_h as i32).into() {
+        return false;
+    }
+    let configured = settings.config.output.named.get(&name);
+    let Some(mode) = choose_mode(connector, &name, configured.and_then(|c| c.mode.as_deref()))
+    else {
+        return false;
+    };
+    let wl_mode = Mode::from(mode);
+    let moved = s.output.current_mode() != Some(wl_mode);
+    if moved {
+        let elements = DrmOutputRenderElements::default();
+        if let Err(e) = s.drm.use_mode::<_, Draw>(mode, renderer, &elements) {
+            tracing::warn!(name, "could not change the mode in place: {e}");
+            return false;
+        }
+        s.output
+            .change_current_state(Some(wl_mode), None, None, None);
+        s.refresh_ns = 1_000_000_000_000 / u64::from(wl_mode.refresh.max(1) as u32);
+        s.last_vblank_ns = None;
+        s.target_ns = None;
+        s.redraw = true;
+        let area = logical_area(
+            s.output.current_location(),
+            wl_mode.size,
+            s.output.current_transform(),
+            s.output.current_scale().fractional_scale(),
+        );
+        layout.set_output_area(s.id, area);
+        tracing::info!(
+            name,
+            w = wl_mode.size.w,
+            h = wl_mode.size.h,
+            refresh = mode.vrefresh(),
+            "output mode changed"
+        );
+    }
+    s.output.set_preferred(wl_mode);
+    if moved {
+        reconfigure_outputs(state);
+        state.reserve_layers();
+        state.reconfigure_lock();
+    }
+    true
+}
+
+/// The mode matching `WIDTHxHEIGHT` or `WIDTHxHEIGHT@HZ`, the highest rate
+/// when none is given and the nearest one when it is.
+pub(super) fn pick_mode(modes: &[control::Mode], spec: &str) -> Option<control::Mode> {
+    let (size, rate) = match spec.split_once('@') {
+        Some((size, rate)) => (size, Some(rate.trim().parse::<f64>().ok()?)),
+        None => (spec, None),
+    };
+    let (w, h) = size.trim().split_once('x')?;
+    let size = (w.trim().parse::<u16>().ok()?, h.trim().parse::<u16>().ok()?);
+    let fitting = modes.iter().filter(|m| m.size() == size);
+    match rate {
+        Some(r) => fitting
+            .min_by(|a, b| {
+                let off = |m: &&control::Mode| (f64::from(m.vrefresh()) - r).abs();
+                off(a).total_cmp(&off(b))
+            })
+            .copied(),
+        None => fitting.max_by_key(|m| m.vrefresh()).copied(),
+    }
+}
+
+pub(super) fn transform(t: OutputTransform) -> Transform {
+    match t {
+        OutputTransform::Normal => Transform::Normal,
+        OutputTransform::Rotate90 => Transform::_90,
+        OutputTransform::Rotate180 => Transform::_180,
+        OutputTransform::Rotate270 => Transform::_270,
+        OutputTransform::Flipped => Transform::Flipped,
+        OutputTransform::Flipped90 => Transform::Flipped90,
+        OutputTransform::Flipped180 => Transform::Flipped180,
+        OutputTransform::Flipped270 => Transform::Flipped270,
+    }
+}
+
+/// Outputs without a configured position are laid out left to right in
+/// their current order, so one rotating pushes its neighbours along.
+pub fn reconfigure_outputs(state: &mut State) {
+    let State {
+        backend: Backend::Drm(drm),
+        wm: Wm { layout, space, .. },
+        settings,
+        ..
+    } = state
+    else {
+        return;
+    };
+    let mut surfaces: Vec<&mut Surface> = drm.surfaces.values_mut().filter(|s| !s.parked).collect();
+    surfaces.sort_by_cached_key(|s| {
+        let name = s.output.name();
+        (
+            s.output.current_location().x,
+            !crate::power::internal(&name),
+        )
+    });
+    let mut right = 0;
+    let mut changed = false;
+    for s in surfaces {
+        let config = settings
+            .config
+            .output
+            .named
+            .get(&s.output.name())
+            .cloned()
+            .unwrap_or_default();
+        let Some(mode) = s.output.current_mode() else {
+            continue;
+        };
+        let transform = transform(config.transform);
+        let scale = config.scale();
+        let position: Point<i32, Logical> = match config.position {
+            Some([x, y]) => (x, y).into(),
+            None => (right, 0).into(),
+        };
+        let area = logical_area(position, mode.size, transform, scale);
+        right = right.max(area.right().ceil() as i32);
+        if s.output.current_transform() == transform
+            && s.output.current_location() == position
+            && s.output.current_scale().fractional_scale() == scale
+        {
+            continue;
+        }
+        s.output.change_current_state(
+            None,
+            Some(transform),
+            Some(Scale::Fractional(scale)),
+            Some(position),
+        );
+        space.map_output(&s.output, position);
+        layout.set_output_area(s.id, area);
+        s.redraw = true;
+        changed = true;
+        tracing::info!(
+            name = s.output.name(),
+            ?transform,
+            scale,
+            x = position.x,
+            y = position.y,
+            "output reconfigured"
+        );
+    }
+    if changed {
+        state.reserve_layers();
+        state.reconfigure_lock();
+        state.apply_layout();
+    }
+}
+
+pub(super) fn disconnect(state: &mut State, crtc: crtc::Handle) {
+    let Some(drm) = state.backend.drm_mut() else {
+        return;
+    };
+    let Some(surface) = drm.surfaces.remove(&crtc) else {
+        return;
+    };
+    for token in [surface.scheduled, surface.watchdog].into_iter().flatten() {
+        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);
+    state.services.power.forget(&surface.output.name());
+    state.protocols.output_power.output_removed(&surface.output);
+}
+
+/// Takes the output called `name` out of the layout and Space, or puts it
+/// back. Its windows move to the other outputs and return when it does.
+pub fn set_parked(state: &mut State, name: &str, parked: bool) {
+    let State {
+        backend: Backend::Drm(drm),
+        wm: Wm { layout, space, .. },
+        ..
+    } = state
+    else {
+        return;
+    };
+    let Some(s) = drm.surfaces.values_mut().find(|s| s.output.name() == name) else {
+        return;
+    };
+    if s.parked == parked {
+        return;
+    }
+    s.parked = parked;
+    tracing::info!(name, parked, "output parked");
+    if parked {
+        space.unmap_output(&s.output);
+        layout.remove_output(s.id);
+    } else if let Some(mode) = s.output.current_mode() {
+        let position = s.output.current_location();
+        space.map_output(&s.output, position);
+        let scale = s.output.current_scale().fractional_scale();
+        let area = logical_area(position, mode.size, s.output.current_transform(), scale);
+        s.id = layout.add_output(name, area);
+        s.redraw = true;
+    }
+    let pos = state.input.pointer_pos;
+    let held = clamp(state, pos);
+    if held != pos {
+        state.warp_pointer(held, InputTime::now());
+    }
+    if !parked {
+        reconfigure_outputs(state);
+    }
+    state.reserve_layers();
+    state.reconfigure_lock();
+    state.apply_layout();
+}

Added file: crates/monolith/src/drm/pacing.rs+273 additions@@ -0,0 +1,273 @@
+//! When each output renders next, and what happens when its flip lands or
+//! never does.
+
+use crate::state::{State, now_ns};
+use smithay::backend::drm::{
+    DrmEventMetadata, DrmEventTime,
+};
+use smithay::backend::session::Session;
+use smithay::reexports::calloop::timer::{TimeoutAction, Timer};
+use smithay::reexports::calloop::LoopHandle;
+use smithay::reexports::drm::control::crtc;
+use smithay::reexports::wayland_protocols::wp::presentation_time::server::wp_presentation_feedback::Kind;
+use smithay::utils::{Monotonic, Time};
+use smithay::wayland::presentation::Refresh;
+use std::time::Duration;
+use super::{Surface, surface_mut};
+use super::render::render_surface;
+
+/// Frames that only move the cursor stay at or below 60 Hz under VRR, so the
+/// mouse does not override the refresh rate a game is pacing.
+const CURSOR_FRAME_NS: u64 = 16_666_667;
+
+pub(super) fn on_vblank(
+    state: &mut State,
+    crtc: crtc::Handle,
+    meta: &mut Option<DrmEventMetadata>,
+) {
+    let presented = state
+        .backend
+        .drm()
+        .and_then(|d| d.surfaces.get(&crtc))
+        .map(|s| s.output.clone());
+    if let Some(output) = presented {
+        crate::fifo::presented(state, &output);
+    }
+    let Some(surface) = surface_mut(state, crtc) else {
+        return;
+    };
+    let feedback = surface.drm.frame_submitted().unwrap_or_else(|e| {
+        tracing::warn!("frame was not submitted: {e}");
+        None
+    });
+    surface.queued = false;
+    if let Err(e) = state.renderer.absorb_submit_stall() {
+        tracing::warn!("absorbing a submit stall failed: {e}");
+    }
+    let Some(surface) = surface_mut(state, crtc) else {
+        return;
+    };
+    if let Some(mut feedback) = feedback {
+        let (time, clock) = match meta.as_ref().map(|m| m.time) {
+            Some(DrmEventTime::Monotonic(t)) => (t, Kind::HwClock | Kind::HwCompletion),
+            _ => (Duration::from_nanos(now_ns()), Kind::empty()),
+        };
+        let refresh = Duration::from_nanos(surface.refresh_ns);
+        let refresh = if surface.vrr_on {
+            Refresh::variable(refresh)
+        } else {
+            Refresh::fixed(refresh)
+        };
+        let sequence = meta.as_ref().map_or(0, |m| u64::from(m.sequence));
+        feedback.presented(
+            Time::<Monotonic>::from(time),
+            refresh,
+            sequence,
+            Kind::Vsync | clock,
+        );
+    }
+    if let Some(DrmEventTime::Monotonic(t)) = meta.as_ref().map(|m| m.time) {
+        let t = t.as_nanos() as u64;
+        if let Some(target) = surface.target_ns.take() {
+            if t > target + surface.refresh_ns / 2 {
+                surface.budget.missed(surface.refresh_ns);
+                tracing::debug!(
+                    output = surface.output.name(),
+                    late_ns = t - target,
+                    budget_ns = surface.budget.ns(),
+                    "frame missed its vblank"
+                );
+            } else {
+                surface.budget.landed();
+            }
+        }
+        surface.last_vblank_ns = Some(t);
+        surface.presented += 1;
+        let window = t.saturating_sub(surface.stats_since);
+        if window >= 1_000_000_000 {
+            // Under VRR the panel waits for each flip, so the nominal refresh
+            // says nothing about how many vblanks there were.
+            let vblanks = (!surface.vrr_on).then(|| window / surface.refresh_ns.max(1));
+            let cpu = &mut surface.frame_cpu_ns;
+            cpu.sort_unstable();
+            let p99 = cpu.get(cpu.len().saturating_sub(1) * 99 / 100).copied();
+            tracing::debug!(
+                output = surface.output.name(),
+                presented = surface.presented,
+                vblanks,
+                vrr = surface.vrr_on,
+                scanned_out = surface.scanned_out,
+                cpu_p99_us = p99.map(|ns| ns / 1000),
+                budget_us = surface.budget.ns() / 1000,
+                "frame rate"
+            );
+            cpu.clear();
+            surface.scanned_out = 0;
+            surface.presented = 0;
+            surface.stats_since = t;
+        }
+    }
+    if surface.redraw || surface.cursor_redraw {
+        schedule(state, crtc);
+    }
+}
+
+/// Starts a render at the last moment that still makes the next reachable
+/// vblank, so commits arriving until then make it into the frame.
+pub(super) fn schedule(state: &mut State, crtc: crtc::Handle) {
+    let Some(drm) = state.backend.drm_mut() else {
+        return;
+    };
+    if !drm.session.is_active() {
+        return;
+    }
+    let Some(surface) = drm.surfaces.get_mut(&crtc) else {
+        return;
+    };
+    if !surface.powered || surface.queued || surface.scheduled.is_some() {
+        return;
+    }
+    let now = now_ns();
+    if surface.vrr_on {
+        let since_flip = surface
+            .last_vblank_ns
+            .map_or(u64::MAX, |l| now.saturating_sub(l));
+        if surface.redraw || since_flip >= CURSOR_FRAME_NS {
+            draw(state, crtc, now);
+            return;
+        }
+        let wait = Duration::from_nanos(CURSOR_FRAME_NS - since_flip);
+        arm(&drm.handle, surface, crtc, wait, true, move |state| {
+            draw(state, crtc, now_ns());
+        });
+        return;
+    }
+    let Some((vblank, start)) = surface.next_deadline(now) else {
+        draw(state, crtc, now);
+        return;
+    };
+    surface.target_ns = Some(vblank);
+    let wait = Duration::from_nanos(start.saturating_sub(now));
+    arm(&drm.handle, surface, crtc, wait, false, move |state| {
+        let target = state
+            .backend
+            .drm()
+            .and_then(|d| d.surfaces.get(&crtc)?.target_ns);
+        if let Some(target) = target {
+            draw(state, crtc, target);
+        }
+    });
+}
+
+/// Runs `fire` once after `after`, tracked in `surface.scheduled` until then.
+pub(super) fn arm(
+    handle: &LoopHandle<'static, State>,
+    surface: &mut Surface,
+    crtc: crtc::Handle,
+    after: Duration,
+    preemptible: bool,
+    mut fire: impl FnMut(&mut State) + 'static,
+) {
+    let token = handle.insert_source(Timer::from_duration(after), move |_, _, state| {
+        if let Some(s) = surface_mut(state, crtc) {
+            s.scheduled = None;
+        }
+        fire(state);
+        TimeoutAction::Drop
+    });
+    match token {
+        Ok(token) => {
+            surface.scheduled = Some(token);
+            surface.preemptible = preemptible;
+        }
+        Err(e) => tracing::warn!(
+            output = surface.output.name(),
+            "could not arm a render timer: {e}"
+        ),
+    }
+}
+
+/// Arms the flip watchdog unless it already runs.
+pub(super) 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.
+pub(super) 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
+/// try waits a refresh.
+pub(super) fn draw(state: &mut State, crtc: crtc::Handle, target: u64) {
+    if !render_surface(state, crtc, target) {
+        return;
+    }
+    let Some(drm) = state.backend.drm_mut() else {
+        return;
+    };
+    let Some(surface) = drm.surfaces.get_mut(&crtc) else {
+        return;
+    };
+    if surface.scheduled.is_some() {
+        return;
+    }
+    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);
+        },
+    );
+}

Added file: crates/monolith/src/drm/render.rs+232 additions@@ -0,0 +1,232 @@
+//! Drawing one output and queueing the frame.
+
+use super::pacing::{schedule, watch};
+use crate::backend::Backend;
+use crate::frame::{CLEAR, FrameCtx};
+use crate::state::Services;
+use crate::state::{State, now_ns};
+use monolith_config::Vrr;
+use smithay::backend::drm::compositor::PrimaryPlaneElement;
+use smithay::backend::session::Session;
+use smithay::reexports::drm::control::crtc;
+
+/// Frames render without vblanks while retrying or looping on empty frames,
+/// and only a vblank drains the samples.
+const MAX_CPU_SAMPLES: usize = 1024;
+
+/// Renders every output that has something new and no frame in flight.
+pub fn render(state: &mut State) {
+    let Some(drm) = state.backend.drm_mut() else {
+        return;
+    };
+    let cursor = std::mem::take(&mut state.dirty.cursor);
+    let all = std::mem::take(&mut state.dirty.redraw);
+    for s in drm.surfaces.values_mut() {
+        s.redraw |= all;
+        s.cursor_redraw |= cursor;
+        if all
+            && s.preemptible
+            && let Some(token) = s.scheduled.take()
+        {
+            drm.handle.remove(token);
+        }
+    }
+    let ready: Vec<crtc::Handle> = drm
+        .surfaces
+        .iter()
+        .filter(|(_, s)| (s.redraw || s.cursor_redraw) && !s.queued)
+        .map(|(c, _)| *c)
+        .collect();
+    for crtc in ready {
+        schedule(state, crtc);
+    }
+}
+
+/// Draws one output for the vblank at `target`. Returns whether it still
+/// animates without a frame in flight, and so needs another render.
+#[profiling::function]
+pub(super) fn render_surface(state: &mut State, crtc: crtc::Handle, target: u64) -> bool {
+    let State {
+        backend: Backend::Drm(drm),
+        renderer,
+        wm,
+        settings,
+        core,
+        input,
+        services:
+            Services {
+                lock,
+                captures,
+                xwayland,
+                ..
+            },
+        ..
+    } = state
+    else {
+        return false;
+    };
+    if !drm.session.is_active() {
+        return false;
+    }
+    let Some(surface) = drm.surfaces.get_mut(&crtc) else {
+        return false;
+    };
+    if surface.queued || !surface.powered {
+        return false;
+    }
+    surface.cursor_redraw = false;
+    let shown = crate::frame::shown_windows(wm, surface.id, &surface.output, target);
+    let fullscreen = shown.fullscreen;
+    let forced = fullscreen.and_then(|w| wm.get(w)?.rule.vrr);
+    let want_vrr = surface.vrr_capable
+        && forced.unwrap_or(match settings.config.output.vrr {
+            Vrr::Off => false,
+            Vrr::On => true,
+            Vrr::Fullscreen => fullscreen.is_some(),
+        });
+    if want_vrr != surface.vrr_on {
+        match surface.drm.with_compositor(|c| c.use_vrr(want_vrr)) {
+            Ok(()) => {
+                surface.vrr_on = want_vrr;
+                tracing::info!(
+                    output = surface.output.name(),
+                    vrr = want_vrr,
+                    "adaptive sync"
+                );
+            }
+            Err(e) => {
+                tracing::warn!("could not switch adaptive sync: {e}");
+                surface.vrr_capable = false;
+            }
+        }
+    }
+    let began = std::time::Instant::now();
+    let frame_cpu_began = thread_cpu_ns();
+    let now = target;
+    if wm.layout.output(surface.id).is_none() {
+        return false;
+    }
+    let scene_began = std::time::Instant::now();
+    let ctx = FrameCtx {
+        renderer: &mut *renderer,
+        wm: &mut *wm,
+        input: &mut *input,
+        lock: &*lock,
+        deco: &settings.config.decoration,
+        unmanaged: xwayland.as_ref().map_or(&[], |x| &x.unmanaged),
+    };
+    let elements = crate::frame::compose(ctx, surface.id, &surface.output, now, true);
+    let scene_ns = scene_began.elapsed().as_nanos() as u64;
+    let animating = wm.anim.active(now);
+    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)
+    {
+        Ok(result) if !result.is_empty => {
+            let direct = matches!(result.primary_element, PrimaryPlaneElement::Element(_));
+            let feedback = crate::frame::take_presentation_feedback(
+                wm,
+                lock,
+                xwayland.as_ref().map_or(&[], |x| &x.unmanaged),
+                &shown,
+                &surface.output,
+                &result.states,
+            );
+            if direct {
+                surface.scanned_out += 1;
+            }
+            if direct != surface.scanout {
+                surface.scanout = direct;
+                tracing::info!(
+                    output = surface.output.name(),
+                    scanout = direct,
+                    elements = elements.len(),
+                    overlay_planes = result.overlay_elements.len(),
+                    cursor_plane = result.cursor_element.is_some(),
+                    "direct scanout"
+                );
+            }
+            let queue_began = std::time::Instant::now();
+            match surface.drm.queue_frame(feedback) {
+                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) => {
+                    failed = true;
+                    tracing::warn!("queueing a frame failed: {e}");
+                }
+            }
+            queue_ns = queue_began.elapsed().as_nanos() as u64;
+        }
+        Ok(result) => {
+            drop(crate::frame::take_presentation_feedback(
+                wm,
+                lock,
+                xwayland.as_ref().map_or(&[], |x| &x.unmanaged),
+                &shown,
+                &surface.output,
+                &result.states,
+            ));
+            lock.shown(&surface.output);
+        }
+        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;
+    let took = began.elapsed().as_nanos() as u64;
+    surface.budget.record(took);
+    if surface.frame_cpu_ns.len() < MAX_CPU_SAMPLES {
+        surface.frame_cpu_ns.push(thread_cpu_ns() - frame_cpu_began);
+    }
+    if took > surface.refresh_ns / 2 {
+        tracing::debug!(
+            output = surface.output.name(),
+            took_ns = took,
+            scene_ns,
+            render_ns,
+            render_cpu_ns,
+            queue_ns,
+            "slow frame"
+        );
+    }
+    if !surface.queued {
+        surface.target_ns = None;
+    }
+    surface.failures = if failed { surface.failures + 1 } else { 0 };
+    surface.redraw = animating || failed;
+    if !surface.queued {
+        crate::fifo::release_idle(&core.handle, &surface.output);
+    }
+    let elapsed = core.start.elapsed();
+    crate::frame::send_frame_callbacks(
+        wm,
+        lock,
+        xwayland.as_ref().map_or(&[], |x| &x.unmanaged),
+        &shown,
+        &surface.output,
+        elapsed,
+        input.dnd_icon.as_ref(),
+    );
+    crate::frame::send_cursor_frames(wm, input, surface.id, &surface.output, elapsed);
+    (animating || failed) && !surface.queued
+}
+
+/// CPU time this thread has used, to tell a render that works from one that
+/// waits or is descheduled.
+pub(super) fn thread_cpu_ns() -> u64 {
+    let t = smithay::reexports::rustix::time::clock_gettime(
+        smithay::reexports::rustix::time::ClockId::ThreadCPUTime,
+    );
+    t.tv_sec as u64 * 1_000_000_000 + t.tv_nsec as u64
+}

Added file: crates/monolith/src/drm/session.rs+176 additions@@ -0,0 +1,176 @@
+//! The libseat session, udev and libinput setup, and the session pause and
+//! resume that follow.
+
+use super::Drm;
+use super::input::on_input;
+use super::outputs::scan;
+use super::pacing::on_vblank;
+use crate::backend::Backend;
+use crate::devices::Devices;
+use crate::state::State;
+use smithay::backend::allocator::Fourcc;
+use smithay::backend::allocator::gbm::{GbmAllocator, GbmBufferFlags, GbmDevice};
+use smithay::backend::drm::compositor::FrameFlags;
+use smithay::backend::drm::exporter::gbm::GbmFramebufferExporter;
+use smithay::backend::drm::output::DrmOutputManager;
+use smithay::backend::drm::{DrmDevice, DrmDeviceFd, DrmEvent, DrmNode, NodeType};
+use smithay::backend::libinput::{LibinputInputBackend, LibinputSessionInterface};
+use smithay::backend::session::libseat::LibSeatSession;
+use smithay::backend::session::{Event as SessionEvent, Session};
+use smithay::backend::udev::{UdevBackend, UdevEvent, all_gpus, primary_gpu};
+use smithay::reexports::calloop::EventLoop;
+use smithay::reexports::drm::Device as _;
+use smithay::reexports::input::Libinput;
+use smithay::reexports::rustix::fs::OFlags;
+use smithay::utils::DeviceFd;
+use smithay::wayland::drm_syncobj::{DrmSyncobjState, supports_syncobj_eventfd};
+use smithay_drm_extras::drm_scanner::DrmScanner;
+use std::collections::{HashMap, HashSet};
+use std::path::{Path, PathBuf};
+
+/// The GPU monolith drives on bare metal, the seat's primary or else its
+/// first.
+pub fn primary() -> Result<PathBuf, Box<dyn std::error::Error>> {
+    let seat = std::env::var("XDG_SEAT").unwrap_or_else(|_| "seat0".into());
+    Ok(match primary_gpu(&seat)? {
+        Some(p) => p,
+        None => all_gpus(&seat)?.into_iter().next().ok_or("no GPU found")?,
+    })
+}
+
+pub fn init(
+    event_loop: &mut EventLoop<'static, State>,
+    state: &mut State,
+    path: &Path,
+) -> Result<(), Box<dyn std::error::Error>> {
+    let (mut session, notifier) = LibSeatSession::new()?;
+    let seat = session.seat();
+    let node = DrmNode::from_path(path)?;
+    tracing::info!(path = %path.display(), "primary GPU");
+    let fd = session.open(
+        path,
+        OFlags::RDWR | OFlags::CLOEXEC | OFlags::NOCTTY | OFlags::NONBLOCK,
+    )?;
+    let fd = DrmDeviceFd::new(DeviceFd::from(fd));
+    let (device, drm_events) = DrmDevice::new(fd.clone(), true)?;
+    let nvidia = device
+        .get_driver()
+        .map(|d| d.name().to_string_lossy().to_lowercase().contains("nvidia"))
+        .unwrap_or(false);
+    let syncobj = if supports_syncobj_eventfd(&fd) {
+        Some(DrmSyncobjState::new::<State>(
+            &state.core.display,
+            fd.clone(),
+        ))
+    } else {
+        tracing::info!("no syncobj eventfd support, clients stay on implicit sync");
+        None
+    };
+    let gbm = GbmDevice::new(fd)?;
+    let render_node = node
+        .node_with_type(NodeType::Render)
+        .and_then(Result::ok)
+        .unwrap_or(node);
+    let allocator = GbmAllocator::new(
+        gbm.clone(),
+        GbmBufferFlags::RENDERING | GbmBufferFlags::SCANOUT,
+    );
+    let exporter = GbmFramebufferExporter::new(gbm.clone(), render_node.into());
+    let render_formats: Vec<_> = state.renderer.render_formats().iter().copied().collect();
+    let manager = DrmOutputManager::new(
+        device,
+        allocator,
+        exporter,
+        Some(gbm),
+        [Fourcc::Xrgb8888, Fourcc::Argb8888],
+        render_formats,
+    );
+
+    let mut libinput =
+        Libinput::new_with_udev::<LibinputSessionInterface<LibSeatSession>>(session.clone().into());
+    libinput
+        .udev_assign_seat(&seat)
+        .map_err(|()| "libinput could not take the seat")?;
+    let handle = event_loop.handle();
+    handle.insert_source(
+        LibinputInputBackend::new(libinput.clone()),
+        |event, _, state| {
+            on_input(state, event);
+        },
+    )?;
+    handle.insert_source(notifier, |event, _, state| match event {
+        SessionEvent::PauseSession => {
+            if let Some(drm) = state.backend.drm_mut() {
+                drm.libinput.suspend();
+                drm.manager.pause();
+            }
+        }
+        SessionEvent::ActivateSession => {
+            if let Some(drm) = state.backend.drm_mut() {
+                if drm.libinput.resume().is_err() {
+                    tracing::warn!("libinput did not resume");
+                }
+                if let Err(e) = drm.manager.lock().activate(false) {
+                    tracing::warn!("could not reactivate the GPU: {e}");
+                }
+                for s in drm.surfaces.values_mut() {
+                    if let Some(token) = s.scheduled.take() {
+                        drm.handle.remove(token);
+                    }
+                    if let Err(e) = s.drm.frame_submitted() {
+                        tracing::warn!("could not drop the flip left over from the pause: {e}");
+                    }
+                    s.queued = false;
+                    s.last_vblank_ns = None;
+                    s.target_ns = None;
+                    s.failures = 0;
+                    s.redraw = true;
+                    if !s.powered
+                        && let Err(e) = s.drm.with_compositor(|c| c.clear())
+                    {
+                        tracing::warn!("could not keep the output off: {e}");
+                    }
+                }
+            }
+            scan(state);
+            state.dirty.redraw = true;
+        }
+    })?;
+    handle.insert_source(drm_events, |event, meta, state| match event {
+        DrmEvent::VBlank(crtc) => on_vblank(state, crtc, meta),
+        DrmEvent::Error(e) => tracing::warn!("drm: {e}"),
+    })?;
+    let udev = UdevBackend::new(&seat)?;
+    handle.insert_source(udev, move |event, _, state| {
+        if let UdevEvent::Changed { device_id } = event
+            && state
+                .backend
+                .drm()
+                .is_some_and(|d| d.node.dev_id() == device_id && d.session.is_active())
+        {
+            scan(state);
+        }
+    })?;
+
+    state.backend = Backend::Drm(Box::new(Drm {
+        session,
+        libinput,
+        handle,
+        node,
+        render_node,
+        syncobj,
+        manager,
+        scanner: DrmScanner::new(),
+        nvidia,
+        frame_flags: if std::env::var_os("MONOLITH_NO_SCANOUT").is_some() {
+            FrameFlags::empty()
+        } else {
+            FrameFlags::DEFAULT
+        },
+        surfaces: HashMap::new(),
+        failed: HashSet::new(),
+        devices: Devices::default(),
+    }));
+    scan(state);
+    Ok(())
+}

monolith

Commit dbdff401f909

Commit `dbdff401f909`