xwm: Don't do multiple

src/backend/kms/mod.rs

@@ -331,7 +331,6 @@ pub fn init_backend(
     // Create relative pointer global
     RelativePointerManagerState::new::<State>(&dh);
 
-    // TODO: Do multiple Xwaylands for better multigpu
     state.launch_xwayland(Some(primary));
 
     for (dev, path) in udev_dispatcher.as_source_ref().device_list() {

src/backend/render/mod.rs

@@ -298,7 +298,7 @@ where
                 renderer,
                 output,
                 &state.shell.override_redirect_windows,
-                state.xwayland_state.values_mut(),
+                state.xwayland_state.as_mut(),
                 (!move_active && active_output).then_some(&last_active_seat),
                 exclude_workspace_overview,
             )

src/backend/winit.rs

@@ -11,6 +11,7 @@ use crate::{
 use anyhow::{anyhow, Context, Result};
 use smithay::{
     backend::{
+        egl::EGLDevice,
         renderer::{
             damage::DamageTrackedRenderer, gles2::Gles2Renderbuffer, glow::GlowRenderer, ImportDma,
             ImportEgl,
@@ -25,6 +26,7 @@ use smithay::{
         wayland_server::DisplayHandle,
     },
     utils::Transform,
+    wayland::dmabuf::DmabufFeedbackBuilder,
 };
 use std::cell::RefCell;
 use tracing::{error, info, warn};
@@ -257,7 +259,6 @@ pub fn init_backend(
         seats.iter().cloned(),
         &state.common.event_loop_handle,
     );
-
     state.launch_xwayland(None);
 
     Ok(())
@@ -269,21 +270,56 @@ fn init_egl_client_side(
     renderer: &mut WinitGraphicsBackend<GlowRenderer>,
 ) -> Result<()> {
     let bind_result = renderer.renderer().bind_wl_display(dh);
-    match bind_result {
-        Ok(_) => {
+    let render_node = EGLDevice::device_for_display(renderer.renderer().egl_context().display())
+        .and_then(|device| device.try_get_render_node());
+
+    let dmabuf_formats = renderer
+        .renderer()
+        .dmabuf_formats()
+        .cloned()
+        .collect::<Vec<_>>();
+    let dmabuf_default_feedback = match render_node {
+        Ok(Some(node)) => {
+            let dmabuf_default_feedback =
+                DmabufFeedbackBuilder::new(node.dev_id(), dmabuf_formats.clone())
+                    .build()
+                    .unwrap();
+            Some(dmabuf_default_feedback)
+        }
+        Ok(None) => {
+            warn!("Failed to query render node, dmabuf protocol will only advertise v3");
+            None
+        }
+        Err(err) => {
+            warn!(
+                ?err,
+                "Failed to egl device for display, dmabuf protocol will only advertise v3"
+            );
+            None
+        }
+    };
+
+    match dmabuf_default_feedback {
+        Some(feedback) => {
+            state
+                .common
+                .dmabuf_state
+                .create_global_with_default_feedback::<State>(dh, &feedback);
+
             info!("EGL hardware-acceleration enabled.");
-            let dmabuf_formats = renderer
-                .renderer()
-                .dmabuf_formats()
-                .cloned()
-                .collect::<Vec<_>>();
+        }
+        None if bind_result.is_ok() => {
             state
                 .common
                 .dmabuf_state
                 .create_global::<State>(dh, dmabuf_formats);
+            info!("EGL hardware-acceleration enabled.");
         }
-        Err(err) => warn!(?err, "Unable to initialize bind display to EGL."),
-    };
+        None => {
+            let err = bind_result.unwrap_err();
+            warn!(?err, "Unable to initialize bind display to EGL.")
+        }
+    }
 
     Ok(())
 }

src/backend/x11.rs

@@ -35,6 +35,7 @@ use smithay::{
         wayland_server::DisplayHandle,
     },
     utils::{DeviceFd, Transform},
+    wayland::dmabuf::DmabufFeedbackBuilder,
 };
 use std::{cell::RefCell, os::unix::io::OwnedFd};
 use tracing::{debug, error, info, warn};
@@ -351,7 +352,7 @@ pub fn init_backend(
         unsafe { GlowRenderer::new(context) }.with_context(|| "Failed to initialize renderer")?;
 
     init_shaders(&mut renderer).expect("Failed to initialize renderer");
-    init_egl_client_side(dh, state, &mut renderer)?;
+    init_egl_client_side(dh, state, &drm_node, &mut renderer)?;
 
     state.backend = BackendData::X11(X11State {
         handle,
@@ -381,7 +382,6 @@ pub fn init_backend(
         seats.iter().cloned(),
         &state.common.event_loop_handle,
     );
-
     state.launch_xwayland(None);
 
     event_loop
@@ -475,22 +475,32 @@ pub fn init_backend(
     Ok(())
 }
 
-fn init_egl_client_side<R>(dh: &DisplayHandle, state: &mut State, renderer: &mut R) -> Result<()>
+fn init_egl_client_side<R>(
+    dh: &DisplayHandle,
+    state: &mut State,
+    render_node: &DrmNode,
+    renderer: &mut R,
+) -> Result<()>
 where
     R: ImportEgl + ImportDma,
 {
-    let bind_result = renderer.bind_wl_display(dh);
-    match bind_result {
-        Ok(_) => {
-            info!("EGL hardware-acceleration enabled.");
-            let dmabuf_formats = renderer.dmabuf_formats().cloned().collect::<Vec<_>>();
-            state
-                .common
-                .dmabuf_state
-                .create_global::<State>(dh, dmabuf_formats);
-        }
-        Err(err) => warn!(?err, "Unable to initialize bind display to EGL."),
-    };
+    if let Err(err) = renderer.bind_wl_display(dh) {
+        warn!(
+            ?err,
+            "Unable to initialize bind display to EGL. Some older clients may not work correctly."
+        )
+    }
+    let dmabuf_formats = renderer.dmabuf_formats().cloned().collect::<Vec<_>>();
+
+    let default_feedback = DmabufFeedbackBuilder::new(render_node.dev_id(), dmabuf_formats.clone())
+        .build()
+        .unwrap();
+    state
+        .common
+        .dmabuf_state
+        .create_global_with_default_feedback::<State>(dh, &default_feedback);
+
+    info!("EGL hardware-acceleration enabled.");
 
     Ok(())
 }