Disable Smithay use_system_lib to use Rust backend to wayland-rs

It seems this was needed for `renderer.bind_wl_display`. But only in the
X11 and winit backends. Unless there's some less obvious reason to use
the `use_system_lib` feature, it seems undesirable and avoidable.

This uses `WlDrmState` to provide `wl_drm` on those backends instead.

Cargo.lock

@@ -1968,8 +1968,6 @@ dependencies = [
  "drm-fourcc",
  "gbm-sys",
  "libc",
- "wayland-backend",
- "wayland-server",
 ]
 
 [[package]]
@@ -4595,13 +4593,11 @@ dependencies = [
  "thiserror",
  "tracing",
  "udev",
- "wayland-backend",
  "wayland-egl",
  "wayland-protocols",
  "wayland-protocols-misc",
  "wayland-protocols-wlr",
  "wayland-server",
- "wayland-sys",
  "winit",
  "x11rb",
  "xkbcommon",
@@ -5678,9 +5674,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "15a0c8eaff5216d07f226cb7a549159267f3467b289d9a2e52fd3ef5aae2b7af"
 dependencies = [
  "dlib",
- "libc",
  "log",
- "memoffset 0.9.0",
  "once_cell",
  "pkg-config",
 ]

Cargo.toml

@@ -76,7 +76,6 @@ features = [
   "backend_vulkan",
   "backend_x11",
   "desktop",
-  "use_system_lib",
   "renderer_glow",
   "renderer_multi",
   "renderer_pixman",

src/backend/winit.rs

@@ -10,12 +10,13 @@ use crate::{
 use anyhow::{anyhow, Context, Result};
 use smithay::{
     backend::{
+        drm::NodeType,
         egl::EGLDevice,
         renderer::{
             damage::{OutputDamageTracker, RenderOutputResult},
             gles::GlesRenderbuffer,
             glow::GlowRenderer,
-            ImportDma, ImportEgl,
+            ImportDma,
         },
         winit::{self, WinitEvent, WinitGraphicsBackend, WinitVirtualDevice},
     },
@@ -251,51 +252,46 @@ fn init_egl_client_side(
     state: &mut State,
     renderer: &mut WinitGraphicsBackend<GlowRenderer>,
 ) -> Result<()> {
-    let bind_result = renderer.renderer().bind_wl_display(dh);
     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().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
+    match render_node {
+        Ok(Some(node)) => {
+            let feedback = DmabufFeedbackBuilder::new(node.dev_id(), dmabuf_formats.clone())
+                .build()
+                .unwrap();
+
+            let dmabuf_global = state
                 .common
                 .dmabuf_state
                 .create_global_with_default_feedback::<State>(dh, &feedback);
 
+            let render_node = render_node.unwrap().unwrap();
+            let _drm_global_id = state.common.wl_drm_state.create_global::<State>(
+                dh,
+                render_node
+                    .dev_path_with_type(NodeType::Render)
+                    .or_else(|| render_node.dev_path())
+                    .ok_or(anyhow!(
+                        "Could not determine path for gpu node: {}",
+                        render_node
+                    ))?,
+                dmabuf_formats,
+                &dmabuf_global,
+            );
+
             info!("EGL hardware-acceleration enabled.");
         }
-        None if bind_result.is_ok() => {
-            state
-                .common
-                .dmabuf_state
-                .create_global::<State>(dh, dmabuf_formats);
-            info!("EGL hardware-acceleration enabled.");
+        Ok(None) => {
+            warn!("Failed to query render node. Unable to initialize bind display to EGL.")
         }
-        None => {
-            let err = bind_result.unwrap_err();
-            warn!(?err, "Unable to initialize bind display to EGL.")
+        Err(err) => {
+            warn!(
+                ?err,
+                "Failed to egl device for display. Unable to initialize bind display to EGL."
+            )
         }
     }
 

src/backend/x11.rs

@@ -7,7 +7,7 @@ use crate::{
     state::{BackendData, Common},
     utils::prelude::*,
 };
-use anyhow::{Context, Result};
+use anyhow::{anyhow, Context, Result};
 use smithay::{
     backend::{
         allocator::{
@@ -15,14 +15,14 @@ use smithay::{
             gbm::{GbmAllocator, GbmBufferFlags},
             vulkan::{ImageUsageFlags, VulkanAllocator},
         },
-        drm::{DrmDeviceFd, DrmNode},
+        drm::{DrmDeviceFd, DrmNode, NodeType},
         egl::{EGLContext, EGLDevice, EGLDisplay},
         input::{Event, InputEvent},
         renderer::{
             damage::{OutputDamageTracker, RenderOutputResult},
             gles::GlesRenderbuffer,
             glow::GlowRenderer,
-            Bind, ImportDma, ImportEgl,
+            Bind, ImportDma,
         },
         vulkan::{version::Version, Instance, PhysicalDevice},
         x11::{Window, WindowBuilder, X11Backend, X11Event, X11Handle, X11Input, X11Surface},
@@ -343,7 +343,7 @@ pub fn init_backend(
         unsafe { GlowRenderer::new(context) }.with_context(|| "Failed to initialize renderer")?;
 
     init_shaders(&mut renderer).context("Failed to initialize renderer")?;
-    init_egl_client_side(dh, state, &drm_node, &mut renderer)?;
+    init_egl_client_side(dh, state, drm_node, &mut renderer)?;
 
     state.backend = BackendData::X11(X11State {
         handle,
@@ -472,27 +472,32 @@ pub fn init_backend(
 fn init_egl_client_side<R>(
     dh: &DisplayHandle,
     state: &mut State,
-    render_node: &DrmNode,
+    render_node: DrmNode,
     renderer: &mut R,
 ) -> Result<()>
 where
-    R: ImportEgl + ImportDma,
+    R: ImportDma,
 {
-    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 default_feedback =
         DmabufFeedbackBuilder::new(render_node.dev_id(), renderer.dmabuf_formats())
             .build()
             .unwrap();
-    state
+    let dmabuf_global = state
         .common
         .dmabuf_state
         .create_global_with_default_feedback::<State>(dh, &default_feedback);
+    let _drm_global_id = state.common.wl_drm_state.create_global::<State>(
+        dh,
+        render_node
+            .dev_path_with_type(NodeType::Render)
+            .or_else(|| render_node.dev_path())
+            .ok_or(anyhow!(
+                "Could not determine path for gpu node: {}",
+                render_node
+            ))?,
+        renderer.dmabuf_formats().collect(),
+        &dmabuf_global,
+    );
 
     info!("EGL hardware-acceleration enabled.");