monolith

public

Star0

Fork 0

Watch0

223 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `5d5ec436eb31`

tarball

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

6 files changed+131-4

power: take the lid switch from logind and act through it

logind also handled the lid, so "ignore" still suspended and "suspend" ran twice. A handle-lid-switch block inhibitor held for the compositor's lifetime leaves the switch to us, and Suspend/PowerOff go over the same connection with a systemctl fallback. The calls run on a short-lived thread so a slow bus cannot stall the event loop.

Modified file: Cargo.lock+21 additions@@ -201,6 +201,17 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f27ae1dd37df86211c42e150270f82743308803d90a6f6e6651cd730d5e1732f"
 
 [[package]]
+name = "dbus"
+version = "0.9.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3ab69f03cc8c4340c9c8e315114e1658e6775a9b16a04357973aa21cec22b32e"
+dependencies = [
+ "libc",
+ "libdbus-sys",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
 name = "downcast-rs"
 version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -452,6 +463,15 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ce5d3ddc6d3fa000eb1536d85e147bfe31aacaba692ed6a876f95cb7c855be78"
 
 [[package]]
+name = "libdbus-sys"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "328c4789d42200f1eeec05bd86c9c13c7f091d2ba9a6ea35acdf51f31bc0f043"
+dependencies = [
+ "pkg-config",
+]
+
+[[package]]
 name = "libloading"
 version = "0.8.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -544,6 +564,7 @@ name = "monolith"
 version = "0.0.0"
 dependencies = [
  "calloop-wayland-source",
+ "dbus",
  "input",
  "libc",
  "monolith-config",

Modified file: crates/monolith/Cargo.toml+1

@@ -22,6 +22,7 @@ monolith-planner.workspace = true

2222 monolith-protocols.workspace = true

2323 monolith-render-vk.workspace = true

2424 libc = "0.2"

25+dbus = "0.9"

2526 # Raises the libinput bindings smithay uses. 1.23 brings custom acceleration,

2627 # and below 1.27 reading a sticky drag lock default panics.

2728 input = { version = "0.10", default-features = false, features = ["libinput_1_27"] }

Added file: crates/monolith/src/logind.rs+92 additions@@ -0,0 +1,92 @@
+//! The system bus connection to logind, for taking over the lid switch and
+//! for suspending or powering off through it.
+
+use dbus::arg::OwnedFd;
+use dbus::blocking::SyncConnection;
+use std::process::Command;
+use std::sync::Arc;
+use std::time::Duration;
+
+const DEST: &str = "org.freedesktop.login1";
+const PATH: &str = "/org/freedesktop/login1";
+const MANAGER: &str = "org.freedesktop.login1.Manager";
+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,
+}
+
+#[derive(Clone, Copy)]
+pub enum Action {
+    Suspend,
+    Poweroff,
+}
+
+impl Action {
+    fn method(self) -> &'static str {
+        match self {
+            Action::Suspend => "Suspend",
+            Action::Poweroff => "PowerOff",
+        }
+    }
+
+    pub fn verb(self) -> &'static str {
+        match self {
+            Action::Suspend => "suspend",
+            Action::Poweroff => "poweroff",
+        }
+    }
+}
+
+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,
+        })
+    }
+
+    /// 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 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()),
+    }
+}

Modified file: crates/monolith/src/main.rs+7 additions@@ -17,6 +17,7 @@ mod ipc;
 mod launch;
 mod layers;
 mod lock;
+mod logind;
 mod nested;
 mod pacing;
 mod popups;
@@ -275,6 +276,12 @@ fn run(
     signals::init(&event_loop)?;
     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}"),
+        }
+    }
     tracing::info!(socket = ?state.core.socket_name, device = state.renderer.device_name(), "monolith running");
 
     if gpu.is_some() {

Modified file: crates/monolith/src/power.rs+9 additions−4 deletions@@ -2,6 +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::state::{State, now_ns};
 use monolith_config::LidAction;
 use monolith_protocols::output_power::{OutputPowerHandler, OutputPowerState};
@@ -13,6 +14,8 @@ use std::time::Duration;
 
 #[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.
@@ -141,12 +144,14 @@ impl State {
             return;
         }
         power.lid_acted = true;
-        let verb = match self.settings.config.lid.close {
-            LidAction::Suspend => "suspend",
-            LidAction::Poweroff => "poweroff",
+        let action = match self.settings.config.lid.close {
+            LidAction::Suspend => Action::Suspend,
+            LidAction::Poweroff => Action::Poweroff,
             LidAction::Ignore => return,
         };
-        if let Err(e) = self.spawn(&["systemctl".into(), verb.into()]) {
+        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}");
         }
     }

Modified file: flake.nix+1

@@ -47,6 +47,7 @@

4747 libgbm

4848 libdrm

4949 udev

50+ dbus

5051 ];

5152 };

5253 cargoArtifacts = craneLib.buildDepsOnly commonArgs;

monolith

Commit 5d5ec436eb31

Commit `5d5ec436eb31`