monolith

public

Star0

Fork 0

Watch0

279 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `afc75793f411`

tarball

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

3 files changed+94-60

logind: take the lid switch on a thread and again after the bus drops

Logind::connect blocked startup for up to 2 s, and a system bus restart left the held connection dead with nothing to retake the inhibitor. A watcher thread now owns its own connection, retries, and re-inhibits on NameOwnerChanged for login1. Actions use a fresh connection with one systemctl fallback instead of a second copy in power.rs.

Modified file: crates/monolith/src/logind.rs+91 additions−48 deletions@@ -3,21 +3,20 @@
 
 use dbus::arg::OwnedFd;
 use dbus::blocking::SyncConnection;
+use dbus::message::MatchRule;
+use std::convert::Infallible;
 use std::process::Command;
 use std::sync::Arc;
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::time::Duration;
 
 const DEST: &str = "org.freedesktop.login1";
 const PATH: &str = "/org/freedesktop/login1";
 const MANAGER: &str = "org.freedesktop.login1.Manager";
+const BUS: &str = "org.freedesktop.DBus";
 const TIMEOUT: Duration = Duration::from_secs(2);
-
-pub struct Logind {
-    conn: Arc<SyncConnection>,
-    /// Held so that logind leaves the lid switch to us. Closing it releases
-    /// the inhibitor.
-    _lid_lock: OwnedFd,
-}
+const RETRY: Duration = Duration::from_secs(10);
+const IDLE: Duration = Duration::from_secs(3600);
 
 #[derive(Clone, Copy)]
 pub enum Action {
@@ -41,52 +40,96 @@ impl Action {
     }
 }
 
-impl Logind {
-    pub fn connect() -> Result<Self, dbus::Error> {
-        let conn = Arc::new(SyncConnection::new_system()?);
-        let proxy = conn.with_proxy(DEST, PATH, TIMEOUT);
-        let (fd,): (OwnedFd,) = proxy.method_call(
-            MANAGER,
-            "Inhibit",
-            (
-                "handle-lid-switch",
-                "monolith",
-                "monolith handles the lid",
-                "block",
-            ),
-        )?;
-        Ok(Self {
-            conn,
-            _lid_lock: fd,
-        })
+/// Keeps logind away from the lid switch for as long as the process lives. The
+/// connection and the inhibitor are set up on a thread of their own, so a slow
+/// or absent system bus never holds up startup, and both are taken again when
+/// the bus drops or logind restarts.
+pub fn hold_lid() {
+    let spawned = std::thread::Builder::new()
+        .name("logind-lid".into())
+        .spawn(|| {
+            let mut warned = false;
+            loop {
+                let Err(e) = hold(&mut warned);
+                if !warned {
+                    tracing::warn!("cannot hold the lid switch from logind: {e}");
+                    warned = true;
+                }
+                std::thread::sleep(RETRY);
+            }
+        });
+    if let Err(e) = spawned {
+        tracing::warn!("could not start the logind lid thread: {e}");
     }
+}
 
-    /// Asks logind to run the action without waiting for the reply, and falls
-    /// back to systemctl if the call fails. The call can take as long as the
-    /// timeout, so it stays off the event loop.
-    pub fn act(&self, action: Action) {
-        let conn = self.conn.clone();
-        let spawned = std::thread::Builder::new()
-            .name("logind".into())
-            .spawn(move || {
-                let proxy = conn.with_proxy(DEST, PATH, TIMEOUT);
-                let called: Result<(), dbus::Error> =
-                    proxy.method_call(MANAGER, action.method(), (false,));
-                if let Err(e) = called {
-                    tracing::warn!("logind {} failed, using systemctl: {e}", action.verb());
-                    systemctl(action);
-                }
-            });
-        if let Err(e) = spawned {
-            tracing::warn!("could not start the logind thread: {e}");
+fn hold(warned: &mut bool) -> Result<Infallible, dbus::Error> {
+    let conn = SyncConnection::new_system()?;
+    let mut _lid_lock = inhibit(&conn)?;
+    let restarted = Arc::new(AtomicBool::new(false));
+    let seen = restarted.clone();
+    let rule = MatchRule::new_signal(BUS, "NameOwnerChanged").with_sender(BUS);
+    conn.add_match(
+        rule,
+        move |(name, _, owner): (String, String, String), _, _| {
+            if name == DEST && !owner.is_empty() {
+                seen.store(true, Ordering::Relaxed);
+            }
+            true
+        },
+    )?;
+    *warned = false;
+    tracing::info!("holding the lid switch");
+    loop {
+        conn.process(IDLE)?;
+        if restarted.swap(false, Ordering::Relaxed) {
+            _lid_lock = inhibit(&conn)?;
+            tracing::info!("logind restarted, took the lid switch again");
         }
     }
 }
 
-fn systemctl(action: Action) {
-    match Command::new("systemctl").arg(action.verb()).status() {
-        Ok(s) if !s.success() => tracing::warn!("systemctl {} exited with {s}", action.verb()),
-        Ok(_) => {}
-        Err(e) => tracing::warn!("systemctl {} failed: {e}", action.verb()),
+/// The returned descriptor keeps the inhibitor alive, and closing it releases
+/// it.
+fn inhibit(conn: &SyncConnection) -> Result<OwnedFd, dbus::Error> {
+    let proxy = conn.with_proxy(DEST, PATH, TIMEOUT);
+    let (fd,): (OwnedFd,) = proxy.method_call(
+        MANAGER,
+        "Inhibit",
+        (
+            "handle-lid-switch",
+            "monolith",
+            "monolith handles the lid",
+            "block",
+        ),
+    )?;
+    Ok(fd)
+}
+
+/// Asks logind to run the action and falls back to systemctl if the call
+/// fails. It happens on a thread, since the call can take as long as the
+/// timeout, and on a fresh connection, since a long-lived one may have died
+/// with the bus.
+pub fn act(action: Action) {
+    let spawned = std::thread::Builder::new()
+        .name("logind".into())
+        .spawn(move || {
+            let called = SyncConnection::new_system().and_then(|conn| {
+                conn.with_proxy(DEST, PATH, TIMEOUT)
+                    .method_call::<(), _, _, _>(MANAGER, action.method(), (false,))
+            });
+            if let Err(e) = called {
+                tracing::warn!("logind {} failed, using systemctl: {e}", action.verb());
+                match Command::new("systemctl").arg(action.verb()).status() {
+                    Ok(s) if !s.success() => {
+                        tracing::warn!("systemctl {} exited with {s}", action.verb());
+                    }
+                    Ok(_) => {}
+                    Err(e) => tracing::warn!("systemctl {} failed: {e}", action.verb()),
+                }
+            }
+        });
+    if let Err(e) = spawned {
+        tracing::warn!("could not start the logind thread: {e}");
     }
 }

Modified file: crates/monolith/src/main.rs+1 additions−4 deletions@@ -282,10 +282,7 @@ fn run(
     xwayland::init(&mut state);
     state.configure_idle();
     if gpu.is_some() {
-        match logind::Logind::connect() {
-            Ok(logind) => state.services.power.logind = Some(logind),
-            Err(e) => tracing::warn!("cannot take the lid switch from logind: {e}"),
-        }
+        logind::hold_lid();
     }
     tracing::info!(socket = ?state.core.socket_name, device = state.renderer.device_name(), "monolith running");
 

Modified file: crates/monolith/src/power.rs+2 additions−8 deletions@@ -2,7 +2,7 @@
 //! wlr-output-power-management all end up here, and the backend is told what
 //! came out.
 
-use crate::logind::{Action, Logind};
+use crate::logind::Action;
 use crate::state::{State, now_ns};
 use monolith_config::LidAction;
 use monolith_protocols::output_power::{OutputPowerHandler, OutputPowerState};
@@ -18,8 +18,6 @@ const LID_GRACE: Duration = Duration::from_secs(5);
 
 #[derive(Default)]
 pub struct Power {
-    /// Absent on the nested backend, or when the system bus is unreachable.
-    pub logind: Option<Logind>,
     /// Every output is dark until the next input.
     idle_blanked: bool,
     /// Outputs switched off by name, which input does not wake.
@@ -169,11 +167,7 @@ impl State {
             LidAction::Poweroff => Action::Poweroff,
             LidAction::Ignore => return,
         };
-        if let Some(logind) = &power.logind {
-            logind.act(action);
-        } else if let Err(e) = self.spawn(&["systemctl".into(), action.verb().into()]) {
-            tracing::warn!("lid close action failed: {e}");
-        }
+        crate::logind::act(action);
     }
 
     fn wake_idle(&mut self) {

monolith

Commit afc75793f411

Commit `afc75793f411`