monolith

public

Star0

Fork 0

Watch0

30 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `f27fa4c2ade9`

tarball

atagen <boss@atagen.co>2026-10-16 12:59 UTC

6 files changed+77-21

render-vk, monolith: render on the GPU that drives the outputs

The renderer picked its own device, preferring a discrete GPU, which only matched the scanout device by luck. On bare metal monolith now resolves the seat primary GPU first and builds the renderer on the Vulkan device whose primary or render node is that one, using VK_EXT_physical_device_drm.

Modified file: crates/monolith/src/drm.rs+14 additions−6 deletions@@ -32,6 +32,7 @@ use smithay::reexports::rustix::fs::OFlags;
 use smithay::utils::{DeviceFd, Point, Transform};
 use smithay_drm_extras::drm_scanner::{DrmScanEvent, DrmScanner};
 use std::collections::HashMap;
+use std::path::{Path, PathBuf};
 use std::time::Duration;
 
 const CLEAR: [f32; 4] = [0.07, 0.075, 0.09, 1.0];
@@ -75,20 +76,27 @@ impl Surface {
     }
 }
 
+/// 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 path = match primary_gpu(&seat)? {
-        Some(p) => p,
-        None => all_gpus(&seat)?.into_iter().next().ok_or("no GPU found")?,
-    };
-    let node = DrmNode::from_path(&path)?;
+    let node = DrmNode::from_path(path)?;
     tracing::info!(path = %path.display(), "primary GPU");
     let fd = session.open(
-        &path,
+        path,
         OFlags::RDWR | OFlags::CLOEXEC | OFlags::NOCTTY | OFlags::NONBLOCK,
     )?;
     let fd = DrmDeviceFd::new(DeviceFd::from(fd));

Modified file: crates/monolith/src/main.rs+13 additions−4 deletions@@ -117,10 +117,19 @@ fn run(
 ) -> Result<(), Box<dyn std::error::Error>> {
     let mut event_loop: EventLoop<'static, State> = EventLoop::try_new()?;
     let display: Display<State> = Display::new()?;
-    let mut state = State::new(&mut event_loop, display, config)?;
-    match backend {
-        Backend::Drm => drm::init(&mut event_loop, &mut state)?,
-        _ => nested::init(&mut event_loop, &mut state)?,
+    let gpu = match backend {
+        Backend::Drm => Some(drm::primary()?),
+        _ => None,
+    };
+    let node = gpu
+        .as_deref()
+        .map(smithay::backend::drm::DrmNode::from_path)
+        .transpose()?
+        .map(|n| n.dev_id());
+    let mut state = State::new(&mut event_loop, display, config, node)?;
+    match &gpu {
+        Some(path) => drm::init(&mut event_loop, &mut state, path)?,
+        None => nested::init(&mut event_loop, &mut state)?,
     }
     ipc::init(&event_loop, &mut state)?;
     tracing::info!(socket = ?state.socket_name, device = state.renderer.device_name(), "monolith running");

Modified file: crates/monolith/src/state.rs+5 additions−1 deletions@@ -92,6 +92,7 @@ impl State {
         event_loop: &mut EventLoop<'static, State>,
         display: Display<State>,
         config_path: Option<PathBuf>,
+        gpu: Option<u64>,
     ) -> Result<Self, Box<dyn std::error::Error>> {
         let dh = display.handle();
         let config_path = config_path.or_else(Config::path);
@@ -99,7 +100,10 @@ impl State {
             tracing::error!("config: {e}, using the built-in default");
             Config::parse(monolith_config::DEFAULT).expect("the default config parses")
         });
-        let renderer = VulkanRenderer::new()?;
+        let renderer = match gpu {
+            Some(node) => VulkanRenderer::for_node(node)?,
+            None => VulkanRenderer::new()?,
+        };
         let mut dmabuf_state = DmabufState::new();
         let dmabuf_global = dmabuf_state.create_global::<State>(&dh, renderer.dmabuf_formats());
         let mut seat_state = SeatState::new();

Modified file: crates/render-vk/Cargo.toml+1−1

@@ -11,7 +11,7 @@ workspace = true

1111 [dependencies]

1212 ash = "0.38"

1313 glam = { version = "0.33", default-features = false, features = ["std"] }

14-rustix = { version = "1", features = ["event"] }

14+rustix = { version = "1", features = ["event", "fs"] }

1515 gpu-allocator = { version = "0.27", default-features = false, features = ["vulkan"] }

1616 smithay.workspace = true

1717 thiserror = "2"

Modified file: crates/render-vk/src/device.rs+33 additions−8 deletions@@ -51,8 +51,9 @@ impl Drop for Device {
 
 impl Shared {
     /// Opens the first suitable device, or the one whose name contains
-    /// `MONOLITH_VK_DEVICE` when that is set.
-    pub fn new() -> Result<Self, Error> {
+    /// `MONOLITH_VK_DEVICE` when that is set. With `node`, only the device
+    /// behind that DRM device number qualifies.
+    pub fn new(node: Option<u64>) -> Result<Self, Error> {
         let entry = unsafe { ash::Entry::load()? };
         let app = vk::ApplicationInfo::default()
             .application_name(c"monolith")
@@ -65,7 +66,7 @@ impl Shared {
             )?
         };
         let wanted = std::env::var("MONOLITH_VK_DEVICE").ok();
-        let picked = unsafe { pick_physical(&instance, wanted.as_deref()) };
+        let picked = unsafe { pick_physical(&instance, wanted.as_deref(), node) };
         let Some((physical, queue_family, name)) = picked else {
             unsafe { instance.destroy_instance(None) };
             return Err(Error::NoSuitableDevice);
@@ -133,9 +134,24 @@ impl Shared {
     }
 }
 
+/// Whether `physical` is the device behind DRM device number `node`, as its
+/// primary or render node.
+unsafe fn serves_node(instance: &ash::Instance, physical: vk::PhysicalDevice, node: u64) -> bool {
+    let mut drm = vk::PhysicalDeviceDrmPropertiesEXT::default();
+    let mut props = vk::PhysicalDeviceProperties2::default().push_next(&mut drm);
+    unsafe { instance.get_physical_device_properties2(physical, &mut props) };
+    let (major, minor) = (
+        rustix::fs::major(node) as i64,
+        rustix::fs::minor(node) as i64,
+    );
+    (drm.has_primary == vk::TRUE && (drm.primary_major, drm.primary_minor) == (major, minor))
+        || (drm.has_render == vk::TRUE && (drm.render_major, drm.render_minor) == (major, minor))
+}
+
 unsafe fn pick_physical(
     instance: &ash::Instance,
     wanted: Option<&str>,
+    node: Option<u64>,
 ) -> Option<(vk::PhysicalDevice, u32, String)> {
     let devices = unsafe { instance.enumerate_physical_devices() }.ok()?;
     let mut candidates = Vec::new();
@@ -158,11 +174,20 @@ unsafe fn pick_physical(
         if f13.dynamic_rendering == vk::FALSE || f13.synchronization2 == vk::FALSE {
             continue;
         }
-        let has_push = unsafe { instance.enumerate_device_extension_properties(physical) }
-            .unwrap_or_default()
-            .iter()
-            .any(|e| e.extension_name_as_c_str().ok() == Some(ash::khr::push_descriptor::NAME));
-        if !has_push {
+        let extensions =
+            unsafe { instance.enumerate_device_extension_properties(physical) }.unwrap_or_default();
+        let has = |n: &std::ffi::CStr| {
+            extensions
+                .iter()
+                .any(|e| e.extension_name_as_c_str().ok() == Some(n))
+        };
+        if !has(ash::khr::push_descriptor::NAME) {
+            continue;
+        }
+        if let Some(node) = node
+            && !(has(ash::ext::physical_device_drm::NAME)
+                && unsafe { serves_node(instance, physical, node) })
+        {
             continue;
         }
         let families = unsafe { instance.get_physical_device_queue_family_properties(physical) };

Modified file: crates/render-vk/src/renderer.rs+11 additions−1 deletions@@ -60,7 +60,17 @@ impl fmt::Debug for VulkanRenderer {
 
 impl VulkanRenderer {
     pub fn new() -> Result<Self, Error> {
-        let shared = Arc::new(Shared::new()?);
+        Self::with_node(None)
+    }
+
+    /// A renderer on the GPU behind DRM device number `node`, so it can
+    /// render into buffers that GPU scans out.
+    pub fn for_node(node: u64) -> Result<Self, Error> {
+        Self::with_node(Some(node))
+    }
+
+    fn with_node(node: Option<u64>) -> Result<Self, Error> {
+        let shared = Arc::new(Shared::new(node)?);
         let d = &shared.device.device;
         let pool = unsafe {
             d.create_command_pool(

monolith

Commit f27fa4c2ade9

Commit `f27fa4c2ade9`