kms: Create socket variants for different gpus

To make it possible for clients to choose a gpu,
we create special sockets per gpu, that advertise
their gpu to clients.

src/backend/kms/mod.rs

@@ -47,7 +47,9 @@ use std::{
 
 mod drm_helpers;
 mod session_fd;
+mod socket;
 use session_fd::*;
+use socket::*;
 
 pub struct KmsState {
     devices: HashMap<DrmNode, Device>,
@@ -66,6 +68,7 @@ pub struct Device {
     formats: HashSet<Format>,
     supports_atomic: bool,
     event_token: Option<RegistrationToken>,
+    socket: Option<Socket>,
 }
 
 pub struct Surface {
@@ -246,7 +249,7 @@ impl State {
                                         .spaces
                                         .active_space_mut(&surface.output)
                                         .send_frames(
-                                            state.common.start_time.elapsed().as_millis() as u32,
+                                            state.common.start_time.elapsed().as_millis() as u32
                                         );
                                 }
                                 Err(err) => slog_scope::warn!("Failed to submit frame: {}", err),
@@ -264,6 +267,18 @@ impl State {
             .register_dispatcher(dispatcher.clone())
             .with_context(|| format!("Failed to add drm device to event loop: {}", dev))?;
 
+        let socket = match self.create_socket(render_node, formats.clone().into_iter()) {
+            Ok(socket) => Some(socket),
+            Err(err) => {
+                slog_scope::warn!(
+                    "Failed to initialize hardware-acceleration for clients on {}: {}",
+                    render_node,
+                    err
+                );
+                None
+            }
+        };
+
         let mut device = Device {
             render_node,
             surfaces: HashMap::new(),
@@ -272,6 +287,7 @@ impl State {
             formats,
             supports_atomic,
             event_token: Some(token),
+            socket,
         };
 
         let outputs = device.enumerate_surfaces()?.added; // There are no removed outputs on newly added devices
@@ -335,6 +351,9 @@ impl State {
             if let Some(token) = device.event_token.take() {
                 self.common.event_loop_handle.remove(token);
             }
+            if let Some(socket) = device.socket.take() {
+                self.common.event_loop_handle.remove(socket.token);
+            }
         }
         Ok(())
     }
@@ -442,7 +461,11 @@ impl Device {
                 let backend = state.backend.kms();
                 if let Some(device) = backend.devices.get_mut(&dev_id) {
                     if let Some(surface) = device.surfaces.get_mut(&crtc) {
-                        if let Err(err) = surface.render_output(&mut backend.api, &backend.primary, &device.render_node, &mut state.common) {
+                        if let Err(err) = surface.render_output(
+                            &mut backend.api,
+                            &device.render_node,
+                            &mut state.common,
+                        ) {
                             slog_scope::error!("Error rendering: {}", err);
                             // TODO re-schedule?
                         }
@@ -471,18 +494,47 @@ impl Device {
     }
 }
 
+const MAX_CPU_COPIES: usize = 3;
+
 impl Surface {
     pub fn render_output(
         &mut self,
         api: &mut GpuManager<EglGlesBackend>,
-        render_node: &DrmNode,
         target_node: &DrmNode,
         state: &mut Common,
     ) -> Result<()> {
-        let mut renderer = api
+        let nodes = state
-            .renderer(render_node, target_node)
+            .spaces
-            .unwrap();
+            .active_space(&self.output)
-        
+            .windows()
+            .flat_map(|w| {
+                w.toplevel()
+                    .get_surface()?
+                    .as_ref()
+                    .client()?
+                    .data_map()
+                    .get::<DrmNode>()
+                    .cloned()
+            })
+            .collect::<Vec<_>>();
+        let render_node = if nodes.contains(&target_node) || nodes.len() < MAX_CPU_COPIES {
+            &target_node
+        } else {
+            nodes
+                .iter()
+                .fold(HashMap::new(), |mut count_map, node| {
+                    let count = count_map.entry(node).or_insert(0);
+                    *count += 1;
+                    count_map
+                })
+                .into_iter()
+                .reduce(|a, b| if a.1 > b.1 { a } else { b })
+                .map(|(node, _)| node)
+                .unwrap_or(&target_node)
+        };
+
+        let mut renderer = api.renderer(render_node, &target_node).unwrap();
+
         let (buffer, age) = self
             .surface
             .next_buffer()

src/backend/kms/socket.rs

@@ -0,0 +1,173 @@
+// SPDX-License-Identifier: GPL-3.0-only
+
+use anyhow::{Context, Result};
+use smithay::{
+    backend::{
+        allocator::Format,
+        drm::DrmNode,
+        renderer::{gles2::Gles2Renderbuffer, ImportDma},
+    },
+    reexports::{
+        calloop::{generic::Generic, Interest, Mode, PostAction, RegistrationToken},
+        wayland_protocols::unstable::linux_dmabuf,
+        wayland_server::Client,
+    },
+    wayland::dmabuf::init_dmabuf_global_with_filter,
+};
+
+use std::{
+    env,
+    os::unix::{
+        io::{AsRawFd, IntoRawFd, RawFd},
+        net::UnixListener,
+    },
+    path::PathBuf,
+};
+
+use crate::{state::State, utils::GlobalDrop, wayland::init_wl_drm_global};
+
+pub struct Socket {
+    pub token: RegistrationToken,
+    pub drm_global: GlobalDrop<crate::wayland::wl_drm::WlDrm>,
+    pub dmabuf_global: GlobalDrop<linux_dmabuf::v1::server::zwp_linux_dmabuf_v1::ZwpLinuxDmabufV1>,
+}
+
+impl State {
+    pub(super) fn create_socket(
+        &mut self,
+        render_node: DrmNode,
+        formats: impl Iterator<Item = Format>,
+    ) -> Result<Socket> {
+        let formats = formats.collect::<Vec<_>>();
+        let is_primary = self.backend.kms().primary == render_node;
+        let socket_path = PathBuf::from(env::var("XDG_RUNTIME_DIR").unwrap()).join(format!(
+            "{}-{}",
+            &self.common.socket.to_string_lossy(),
+            render_node
+                .dev_path()
+                .unwrap()
+                .file_name()
+                .unwrap()
+                .to_string_lossy()
+        ));
+        // HACK!
+        let _ = std::fs::remove_file(&socket_path);
+
+        let listener = UnixListener::bind(socket_path.clone())
+            .with_context(|| format!("Failed to bind socket to {}", socket_path.display()))?;
+        listener.set_nonblocking(true)?;
+        let listener = WaylandListener(listener);
+        let token = self
+            .common
+            .event_loop_handle
+            .insert_source(
+                Generic::new(listener, Interest::READ, Mode::Edge),
+                move |_, listener, state: &mut State| {
+                    loop {
+                        match listener.0.accept() {
+                            Ok((stream, _)) => {
+                                let display = state.common.display.clone();
+                                let client = unsafe {
+                                    display
+                                        .borrow_mut()
+                                        .create_client(stream.into_raw_fd(), state)
+                                };
+                                client
+                                    .data_map()
+                                    .insert_if_missing_threadsafe(|| render_node);
+                            }
+                            Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => {
+                                // we have exhausted all the pending connections
+                                break;
+                            }
+                            Err(e) => {
+                                // this is a legitimate error
+                                if let Ok(addr) = listener.0.local_addr() {
+                                    if let Some(path) = addr.as_pathname() {
+                                        slog_scope::error!(
+                                    "Error accepting connection on listening socket {} : {}",
+                                    path.display(),
+                                    e
+                                );
+                                        return Err(e);
+                                    }
+                                }
+                                slog_scope::error!(
+                                    "Error accepting connection on listening socket <unnamed> : {}",
+                                    e
+                                );
+                                return Err(e);
+                            }
+                        }
+                    }
+
+                    Ok(PostAction::Continue)
+                },
+            )
+            .context("Failed to add gpu-wayland socket to the event loop")?;
+
+        // initialize globals
+        let filter = move |client: Client| {
+            let dev_id = client.data_map().get::<DrmNode>();
+            if dev_id.is_none() && is_primary {
+                client
+                    .data_map()
+                    .insert_if_missing_threadsafe(|| render_node);
+            }
+            dev_id.map(|x| *x == render_node).unwrap_or(is_primary)
+        };
+
+        let drm_global = init_wl_drm_global(
+            &mut *self.common.display.borrow_mut(),
+            render_node.dev_path().unwrap(),
+            formats.clone(),
+            filter.clone(),
+        );
+        let dmabuf_global = init_dmabuf_global_with_filter(
+            &mut *self.common.display.borrow_mut(),
+            formats,
+            move |buf, mut ddata| {
+                let state = ddata.get::<State>().unwrap();
+                state
+                    .backend
+                    .kms()
+                    .api
+                    .renderer::<Gles2Renderbuffer>(&render_node, &render_node)
+                    .map(|mut renderer| renderer.import_dmabuf(buf, None).is_ok())
+                    .unwrap_or(false)
+            },
+            filter,
+            None,
+        );
+
+        slog_scope::info!(
+            "Adding socket at {} for gpu {}",
+            socket_path.display(),
+            render_node
+        );
+
+        Ok(Socket {
+            token,
+            drm_global: GlobalDrop::from(drm_global),
+            dmabuf_global: GlobalDrop::from(dmabuf_global),
+        })
+    }
+}
+
+struct WaylandListener(UnixListener);
+
+impl AsRawFd for WaylandListener {
+    fn as_raw_fd(&self) -> RawFd {
+        self.0.as_raw_fd()
+    }
+}
+
+impl Drop for WaylandListener {
+    fn drop(&mut self) {
+        if let Ok(socketaddr) = self.0.local_addr() {
+            if let Some(path) = socketaddr.as_pathname() {
+                let _ = ::std::fs::remove_file(path);
+            }
+        }
+    }
+}