monolith

public

Star0

Fork 0

Watch0

71 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `845a622a162f`

tarball

atagen <boss@atagen.co>2026-10-17 02:49 UTC

11 files changed+152-81

monolith: make the backend an enum

The DRM and nested backends were two Options on State, plus fields that only one of them filled: the nested output id, the render node and the syncobj global. Each now lives in its backend, and after_dispatch renders the one that runs instead of calling both and letting one return early. The set is closed, and a headless variant for tests is the only addition planned.

Added file: crates/monolith/src/backend.rs+64 additions@@ -0,0 +1,64 @@
+//! Where frames go and input comes from. The set is closed: bare metal and
+//! a window on another compositor, and later a headless one for tests.
+
+use crate::drm::Drm;
+use crate::nested::Host;
+use monolith_layout::OutputId;
+use smithay::backend::drm::DrmNode;
+use smithay::output::Output;
+use smithay::wayland::drm_syncobj::DrmSyncobjState;
+
+pub enum Backend {
+    /// Before `drm::init` or `nested::init` has run.
+    Starting,
+    Drm(Box<Drm>),
+    Nested(Box<Host>),
+}
+
+impl Backend {
+    pub fn drm(&self) -> Option<&Drm> {
+        match self {
+            Backend::Drm(d) => Some(d),
+            _ => None,
+        }
+    }
+
+    pub fn drm_mut(&mut self) -> Option<&mut Drm> {
+        match self {
+            Backend::Drm(d) => Some(d),
+            _ => None,
+        }
+    }
+
+    pub fn nested(&self) -> Option<&Host> {
+        match self {
+            Backend::Nested(h) => Some(h),
+            _ => None,
+        }
+    }
+
+    pub fn nested_mut(&mut self) -> Option<&mut Host> {
+        match self {
+            Backend::Nested(h) => Some(h),
+            _ => None,
+        }
+    }
+
+    /// The smithay output behind a layout output.
+    pub fn output(&self, o: OutputId) -> Option<Output> {
+        match self {
+            Backend::Drm(d) => d.output(o),
+            Backend::Nested(h) => (h.output_id == o).then(|| h.output.clone()),
+            Backend::Starting => None,
+        }
+    }
+
+    /// The node clients allocate dmabufs on, known on bare metal.
+    pub fn render_node(&self) -> Option<DrmNode> {
+        self.drm().map(|d| d.render_node)
+    }
+
+    pub fn syncobj_mut(&mut self) -> Option<&mut DrmSyncobjState> {
+        self.drm_mut()?.syncobj.as_mut()
+    }
+}

Modified file: crates/monolith/src/capture.rs+2 additions−2 deletions@@ -163,7 +163,7 @@ impl State {
     }
 
     fn constraints(&self, size: (i32, i32)) -> BufferConstraints {
-        let dma = self.render_node.map(|node| {
+        let dma = self.backend.render_node().map(|node| {
             let mut formats: Vec<(Fourcc, Vec<_>)> = Vec::new();
             for f in self.renderer.render_formats().iter() {
                 match formats.iter_mut().find(|(c, _)| *c == f.code) {
@@ -302,7 +302,7 @@ impl State {
     fn output_named(&self, name: &str) -> Option<(OutputId, Output)> {
         self.layout
             .outputs()
-            .filter_map(|(o, _)| Some((o, self.smithay_output(o)?)))
+            .filter_map(|(o, _)| Some((o, self.backend.output(o)?)))
             .find(|(_, out)| out.name() == name)
     }
 }

Modified file: crates/monolith/src/commands.rs+1−1

@@ -176,7 +176,7 @@ impl State {

176176 if let Some(sock) = &self.services.ipc.path {

177177 cmd.env("MONOLITH_SOCKET", sock);

178178 }

179- if self.drm.is_some() {

179+ if self.backend.drm().is_some() {

180180 cmd.env("XDG_CURRENT_DESKTOP", "monolith")

181181 .env("XDG_SESSION_TYPE", "wayland");

182182 }

Modified file: crates/monolith/src/drm.rs+45 additions−27 deletions@@ -2,6 +2,7 @@
 //! connectors, libinput for input, and one smithay DRM output per connector,
 //! each rendered when its own vblank lands.
 
+use crate::backend::Backend;
 use crate::scene::Draw;
 use crate::state::Services;
 use crate::state::{State, now_ns};
@@ -54,6 +55,8 @@ pub struct Drm {
     libinput: Libinput,
     handle: LoopHandle<'static, State>,
     node: DrmNode,
+    pub render_node: DrmNode,
+    pub syncobj: Option<DrmSyncobjState>,
     manager: Manager,
     scanner: DrmScanner,
     nvidia: bool,
@@ -193,20 +196,20 @@ pub fn init(
         .get_driver()
         .map(|d| d.name().to_string_lossy().to_lowercase().contains("nvidia"))
         .unwrap_or(false);
-    if supports_syncobj_eventfd(&fd) {
-        state.syncobj = Some(DrmSyncobjState::new::<State>(
+    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);
-    state.render_node = Some(render_node);
     let allocator = GbmAllocator::new(
         gbm.clone(),
         GbmBufferFlags::RENDERING | GbmBufferFlags::SCANOUT,
@@ -236,13 +239,13 @@ pub fn init(
     )?;
     handle.insert_source(notifier, |event, _, state| match event {
         SessionEvent::PauseSession => {
-            if let Some(drm) = state.drm.as_mut() {
+            if let Some(drm) = state.backend.drm_mut() {
                 drm.libinput.suspend();
                 drm.manager.pause();
             }
         }
         SessionEvent::ActivateSession => {
-            if let Some(drm) = state.drm.as_mut() {
+            if let Some(drm) = state.backend.drm_mut() {
                 if drm.libinput.resume().is_err() {
                     tracing::warn!("libinput did not resume");
                 }
@@ -265,19 +268,21 @@ pub fn init(
     handle.insert_source(udev, move |event, _, state| {
         if let UdevEvent::Changed { device_id } = event
             && state
-                .drm
-                .as_ref()
+                .backend
+                .drm()
                 .is_some_and(|d| d.node.dev_id() == device_id)
         {
             scan(state);
         }
     })?;
 
-    state.drm = Some(Drm {
+    state.backend = Backend::Drm(Box::new(Drm {
         session,
         libinput,
         handle,
         node,
+        render_node,
+        syncobj,
         manager,
         scanner: DrmScanner::new(),
         nvidia,
@@ -287,14 +292,14 @@ pub fn init(
             FrameFlags::DEFAULT
         },
         surfaces: HashMap::new(),
-    });
+    }));
     scan(state);
     Ok(())
 }
 
 /// Brings outputs in line with what is plugged in.
 fn scan(state: &mut State) {
-    let Some(drm) = state.drm.as_mut() else {
+    let Some(drm) = state.backend.drm_mut() else {
         return;
     };
     let events: Vec<DrmScanEvent> = match drm.scanner.scan_connectors(drm.manager.device()) {
@@ -335,7 +340,7 @@ fn connect(state: &mut State, connector: connector::Info, crtc: crtc::Handle) {
         return;
     };
     let State {
-        drm: Some(drm),
+        backend: Backend::Drm(drm),
         renderer,
         layout,
         space,
@@ -431,7 +436,7 @@ fn connect(state: &mut State, connector: connector::Info, crtc: crtc::Handle) {
 }
 
 fn disconnect(state: &mut State, crtc: crtc::Handle) {
-    let Some(drm) = state.drm.as_mut() else {
+    let Some(drm) = state.backend.drm_mut() else {
         return;
     };
     let Some(surface) = drm.surfaces.remove(&crtc) else {
@@ -445,16 +450,21 @@ fn disconnect(state: &mut State, crtc: crtc::Handle) {
     state.layout.remove_output(surface.id);
 }
 
-/// The smithay output for a layout output, for protocols that need one.
-pub fn output_for(drm: &Drm, id: OutputId) -> Option<Output> {
-    drm.surfaces
-        .values()
-        .find(|s| s.id == id)
-        .map(|s| s.output.clone())
+impl Drm {
+    pub fn output(&self, id: OutputId) -> Option<Output> {
+        self.surfaces
+            .values()
+            .find(|s| s.id == id)
+            .map(|s| s.output.clone())
+    }
 }
 
 fn on_vblank(state: &mut State, crtc: crtc::Handle, meta: &mut Option<DrmEventMetadata>) {
-    let Some(surface) = state.drm.as_mut().and_then(|d| d.surfaces.get_mut(&crtc)) else {
+    let Some(surface) = state
+        .backend
+        .drm_mut()
+        .and_then(|d| d.surfaces.get_mut(&crtc))
+    else {
         return;
     };
     if let Err(e) = surface.drm.frame_submitted() {
@@ -464,7 +474,11 @@ fn on_vblank(state: &mut State, crtc: crtc::Handle, meta: &mut Option<DrmEventMe
     if let Err(e) = state.renderer.absorb_submit_stall() {
         tracing::warn!("absorbing a submit stall failed: {e}");
     }
-    let Some(surface) = state.drm.as_mut().and_then(|d| d.surfaces.get_mut(&crtc)) else {
+    let Some(surface) = state
+        .backend
+        .drm_mut()
+        .and_then(|d| d.surfaces.get_mut(&crtc))
+    else {
         return;
     };
     if let Some(DrmEventTime::Monotonic(t)) = meta.as_ref().map(|m| m.time) {
@@ -506,7 +520,7 @@ fn on_vblank(state: &mut State, crtc: crtc::Handle, meta: &mut Option<DrmEventMe
 /// 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.drm.as_mut() else {
+    let Some(drm) = state.backend.drm_mut() else {
         return;
     };
     let Some(surface) = drm.surfaces.get_mut(&crtc) else {
@@ -526,7 +540,11 @@ fn schedule(state: &mut State, crtc: crtc::Handle) {
         }
         let wait = Timer::from_duration(Duration::from_nanos(CURSOR_FRAME_NS - since_flip));
         let token = drm.handle.insert_source(wait, move |_, _, state| {
-            if let Some(s) = state.drm.as_mut().and_then(|d| d.surfaces.get_mut(&crtc)) {
+            if let Some(s) = state
+                .backend
+                .drm_mut()
+                .and_then(|d| d.surfaces.get_mut(&crtc))
+            {
                 s.scheduled = None;
             }
             draw(state, crtc, now_ns());
@@ -542,7 +560,7 @@ fn schedule(state: &mut State, crtc: crtc::Handle) {
     surface.target_ns = Some(vblank);
     let wait = Timer::from_duration(Duration::from_nanos(start.saturating_sub(now)));
     let token = drm.handle.insert_source(wait, move |_, _, state| {
-        let target = state.drm.as_mut().and_then(|d| {
+        let target = state.backend.drm_mut().and_then(|d| {
             let s = d.surfaces.get_mut(&crtc)?;
             s.scheduled = None;
             s.target_ns
@@ -563,7 +581,7 @@ fn draw(state: &mut State, crtc: crtc::Handle, target: u64) {
 
 /// Renders every output that has something new and no frame in flight.
 pub fn render(state: &mut State) {
-    let Some(drm) = state.drm.as_mut() else {
+    let Some(drm) = state.backend.drm_mut() else {
         return;
     };
     let cursor = std::mem::take(&mut state.cursor_moved);
@@ -588,7 +606,7 @@ pub fn render(state: &mut State) {
 #[profiling::function]
 fn render_surface(state: &mut State, crtc: crtc::Handle, target: u64) -> bool {
     let State {
-        drm: Some(drm),
+        backend: Backend::Drm(drm),
         renderer,
         layout,
         windows,

Modified file: crates/monolith/src/handlers.rs+1−1

@@ -274,7 +274,7 @@ smithay::delegate_dispatch2!(State);

274274

275275 impl DrmSyncobjHandler for State {

276276 fn drm_syncobj_state(&mut self) -> Option<&mut DrmSyncobjState> {

277- self.syncobj.as_mut()

277+ self.backend.syncobj_mut()

278278 }

279279 }

280280

Modified file: crates/monolith/src/input.rs+1−1

@@ -121,7 +121,7 @@ impl State {

121121 }

122122 }

123123 Some(Some(Action::Vt(vt))) => {

124- if let Some(drm) = self.drm.as_mut()

124+ if let Some(drm) = self.backend.drm_mut()

125125 && let Err(e) = drm.session.change_vt(vt)

126126 {

127127 tracing::warn!("switching to VT {vt} failed: {e}");

Modified file: crates/monolith/src/layers.rs+1−1

@@ -112,7 +112,7 @@ impl State {

112112 let outputs: Vec<OutputId> = self.layout.outputs().map(|(o, _)| o).collect();

113113 let mut changed = false;

114114 for o in outputs {

115- let Some(output) = self.smithay_output(o) else {

115+ let Some(output) = self.backend.output(o) else {

116116 continue;

117117 };

118118 let Some(area) = self.layout.output(o).map(|out| out.area) else {

Modified file: crates/monolith/src/main.rs+1

@@ -1,5 +1,6 @@

11 mod activation;

22 mod anim;

3+mod backend;

34 mod capture;

45 mod commands;

56 mod cursor;

Modified file: crates/monolith/src/nested/mod.rs+19 additions−15 deletions@@ -5,10 +5,11 @@
 
 mod input;
 
+use crate::backend::Backend;
 use crate::state::Services;
 use crate::state::State;
 use calloop_wayland_source::WaylandSource;
-use monolith_layout::Rect;
+use monolith_layout::{OutputId, Rect};
 use monolith_render_vk::VulkanAllocator;
 use smithay::backend::allocator::dmabuf::Dmabuf;
 use smithay::backend::allocator::{Format, Fourcc, Modifier, Slot, Swapchain};
@@ -35,6 +36,7 @@ const DEFAULT_SIZE: (i32, i32) = (1280, 800);
 const CLOCK_MONOTONIC: u32 = 1;
 
 pub struct Host {
+    pub output_id: OutputId,
     pub size: Size<i32, Logical>,
     pub output: Output,
     conn: Connection,
@@ -137,9 +139,10 @@ pub fn init(
         f64::from(DEFAULT_SIZE.0),
         f64::from(DEFAULT_SIZE.1),
     );
-    state.output_id = Some(state.layout.add_output("nested", area));
+    let output_id = state.layout.add_output("nested", area);
 
-    state.host = Some(Host {
+    state.backend = Backend::Nested(Box::new(Host {
+        output_id,
         size: DEFAULT_SIZE.into(),
         damage: OutputDamageTracker::from_output(&output),
         output,
@@ -159,7 +162,7 @@ pub fn init(
         monotonic: false,
         last_present_ns: None,
         refresh_ns: 16_666_667,
-    });
+    }));
     queue.roundtrip(state)?;
     queue.roundtrip(state)?;
     WaylandSource::new(conn, queue).insert(event_loop.handle())?;
@@ -169,7 +172,7 @@ pub fn init(
 /// Renders a frame if something changed and the host is ready for one.
 pub fn render(state: &mut State) {
     let State {
-        host,
+        backend,
         renderer,
         space,
         needs_redraw,
@@ -179,7 +182,6 @@ pub fn render(state: &mut State) {
         anim,
         borders,
         settings,
-        output_id,
         services:
             Services {
                 lock,
@@ -189,7 +191,9 @@ pub fn render(state: &mut State) {
             },
         ..
     } = state;
-    let Some(host) = host.as_mut() else { return };
+    let Some(host) = backend.nested_mut() else {
+        return;
+    };
     if !host.configured || host.frame_pending || !*needs_redraw {
         return;
     }
@@ -230,7 +234,7 @@ pub fn render(state: &mut State) {
                 return;
             }
         };
-        let Some(o) = *output_id else { return };
+        let o = host.output_id;
         let elements = crate::lock::elements(lock, renderer, &host.output).unwrap_or_else(|| {
             crate::scene::build(
                 layout,
@@ -407,7 +411,7 @@ impl Dispatch<xdg_surface::XdgSurface, ()> for State {
     ) {
         if let xdg_surface::Event::Configure { serial } = event {
             surface.ack_configure(serial);
-            if let Some(host) = state.host.as_mut() {
+            if let Some(host) = state.backend.nested_mut() {
                 host.configured = true;
             }
             state.needs_redraw = true;
@@ -427,7 +431,7 @@ impl Dispatch<xdg_toplevel::XdgToplevel, ()> for State {
         match event {
             xdg_toplevel::Event::Configure { width, height, .. } if width > 0 && height > 0 => {
                 let size = Size::from((width, height));
-                if let Some(host) = state.host.as_mut()
+                if let Some(host) = state.backend.nested_mut()
                     && host.size != size
                 {
                     host.pending_size = Some(size);
@@ -455,7 +459,7 @@ impl Dispatch<zwp_linux_dmabuf_v1::ZwpLinuxDmabufV1, ()> for State {
             modifier_hi,
             modifier_lo,
         } = event
-            && let (Ok(code), Some(host)) = (Fourcc::try_from(format), state.host.as_mut())
+            && let (Ok(code), Some(host)) = (Fourcc::try_from(format), state.backend.nested_mut())
         {
             let modifier = Modifier::from((u64::from(modifier_hi) << 32) | u64::from(modifier_lo));
             host.formats.push(Format { code, modifier });
@@ -473,7 +477,7 @@ impl Dispatch<wl_buffer::WlBuffer, ()> for State {
         _: &QueueHandle<Self>,
     ) {
         if let wl_buffer::Event::Release = event
-            && let Some(host) = state.host.as_mut()
+            && let Some(host) = state.backend.nested_mut()
         {
             host.in_flight.retain(|(b, _)| b != buffer);
         }
@@ -490,7 +494,7 @@ impl Dispatch<wl_callback::WlCallback, ()> for State {
         _: &QueueHandle<Self>,
     ) {
         if let wl_callback::Event::Done { .. } = event
-            && let Some(host) = state.host.as_mut()
+            && let Some(host) = state.backend.nested_mut()
         {
             host.frame_pending = false;
         }
@@ -513,7 +517,7 @@ impl Dispatch<wp_presentation::WpPresentation, ()> for State {
         _: &QueueHandle<Self>,
     ) {
         if let wp_presentation::Event::ClockId { clk_id } = event
-            && let Some(host) = state.host.as_mut()
+            && let Some(host) = state.backend.nested_mut()
         {
             host.monotonic = clk_id == CLOCK_MONOTONIC;
         }
@@ -539,7 +543,7 @@ impl Dispatch<wp_presentation_feedback::WpPresentationFeedback, ()> for State {
         else {
             return;
         };
-        let Some(host) = state.host.as_mut() else {
+        let Some(host) = state.backend.nested_mut() else {
             return;
         };
         let secs = (u64::from(tv_sec_hi) << 32) | u64::from(tv_sec_lo);

Modified file: crates/monolith/src/state.rs+16 additions−32 deletions@@ -2,7 +2,6 @@ use crate::anim::{Animator, Ghost};
 use crate::commands::Binds;
 use crate::focus::Focus;
 use crate::globals::Protocols;
-use crate::nested::Host;
 use monolith_config::Config;
 use monolith_layout::{Layout, OutputId, Rect, WindowId};
 use monolith_protocols::workspace::{Group, Snapshot, Workspace};
@@ -42,9 +41,7 @@ pub struct State {
     pub renderer: VulkanRenderer,
     pub space: Space<Window>,
     pub popups: PopupManager,
-    pub host: Option<Host>,
-    pub drm: Option<crate::drm::Drm>,
-    pub syncobj: Option<smithay::wayland::drm_syncobj::DrmSyncobjState>,
+    pub backend: crate::backend::Backend,
     pub cursor: crate::cursor::Cursor,
     pub cursor_status: CursorImageStatus,
     pub needs_redraw: bool,
@@ -56,7 +53,6 @@ pub struct State {
     /// Toplevels that have not committed yet. Rules need their app_id and
     /// title, which clients set after creating the toplevel.
     pub unmapped: Vec<Window>,
-    pub output_id: Option<OutputId>,
     pub suppressed: Vec<Keycode>,
     pub move_inverted: bool,
     pub drag: Option<crate::input::Drag>,
@@ -74,8 +70,6 @@ pub struct State {
     pub placed_by_rule: HashSet<WindowId>,
     /// A layer surface given the keyboard by a click, like a launcher.
     pub layer_focus: Option<WlSurface>,
-    /// The render node clients get dmabufs for, known on bare metal.
-    pub render_node: Option<smithay::backend::drm::DrmNode>,
     pub seat_state: SeatState<State>,
     pub seat: Seat<State>,
 }
@@ -173,9 +167,7 @@ impl State {
             renderer,
             space: Space::default(),
             popups: PopupManager::default(),
-            host: None,
-            drm: None,
-            syncobj: None,
+            backend: crate::backend::Backend::Starting,
             cursor: crate::cursor::Cursor::load(),
             cursor_status: CursorImageStatus::default_named(),
             needs_redraw: true,
@@ -183,7 +175,6 @@ impl State {
             layout,
             windows: HashMap::new(),
             unmapped: Vec::new(),
-            output_id: None,
             suppressed: Vec::new(),
             move_inverted: false,
             drag: None,
@@ -204,7 +195,6 @@ impl State {
             awaiting: HashSet::new(),
             placed_by_rule: HashSet::new(),
             layer_focus: None,
-            render_node: None,
             seat_state,
             seat,
         })
@@ -214,8 +204,11 @@ impl State {
     pub fn after_dispatch(&mut self) {
         self.space.refresh();
         self.popups.cleanup();
-        crate::nested::render(self);
-        crate::drm::render(self);
+        match self.backend {
+            crate::backend::Backend::Drm(_) => crate::drm::render(self),
+            crate::backend::Backend::Nested(_) => crate::nested::render(self),
+            crate::backend::Backend::Starting => {}
+        }
         self.confirm_lock();
         self.complete_captures();
         crate::ipc::broadcast(self);
@@ -225,17 +218,16 @@ impl State {
     }
 
     pub fn resize_output(&mut self, size: Size<i32, Logical>) {
-        if let Some(o) = self.output_id {
+        if let Some(host) = self.backend.nested() {
+            let o = host.output_id;
             let area = Rect::new(0.0, 0.0, f64::from(size.w), f64::from(size.h));
+            let mode = smithay::output::Mode {
+                size: (size.w, size.h).into(),
+                refresh: 60_000,
+            };
+            host.output
+                .change_current_state(Some(mode), None, None, None);
             self.layout.set_output_area(o, area);
-            if let Some(host) = &self.host {
-                let mode = smithay::output::Mode {
-                    size: (size.w, size.h).into(),
-                    refresh: 60_000,
-                };
-                host.output
-                    .change_current_state(Some(mode), None, None, None);
-            }
             self.reserve_layers();
             self.reconfigure_lock();
             self.apply_layout();
@@ -541,14 +533,6 @@ impl State {
         }
     }
 
-    /// The smithay output behind a layout output, on whichever backend runs.
-    pub fn smithay_output(&self, o: OutputId) -> Option<smithay::output::Output> {
-        if let Some(host) = self.host.as_ref().filter(|_| Some(o) == self.output_id) {
-            return Some(host.output.clone());
-        }
-        self.drm.as_ref().and_then(|d| crate::drm::output_for(d, o))
-    }
-
     fn publish_workspaces(&mut self) {
         if !self.protocols.workspaces.has_clients() {
             return;
@@ -562,7 +546,7 @@ impl State {
         let groups = l
             .outputs()
             .filter_map(|(o, _)| {
-                let output = self.smithay_output(o)?;
+                let output = self.backend.output(o)?;
                 // Bars read a tag's existence as having windows, as with
                 // workspaces that come and go, so empty unviewed tags are left out.
                 let workspaces = l

Modified file: crates/monolith/src/toplevels.rs+1−1

@@ -132,7 +132,7 @@ impl State {

132132 app_id,

133133 outputs: w

134134 .and_then(|w| w.output)

135- .and_then(|o| self.smithay_output(o))

135+ .and_then(|o| self.backend.output(o))

136136 .into_iter()

137137 .collect(),

138138 activated: focused == Some(id),

monolith

Commit 845a622a162f

Commit `845a622a162f`