WIP linux-drm-syncobj-v1

anvil/src/shell/mod.rs

@@ -2,6 +2,10 @@ use std::cell::RefCell;
 
 #[cfg(feature = "xwayland")]
 use smithay::xwayland::XWaylandClientData;
+
+#[cfg(feature = "udev")]
+use smithay::wayland::drm_syncobj::DrmSyncobjCachedState;
+
 use smithay::{
     backend::renderer::utils::on_commit_buffer_handler,
     desktop::{
@@ -111,7 +115,17 @@ impl<BackendData: Backend> CompositorHandler for AnvilState<BackendData> {
 
     fn new_surface(&mut self, surface: &WlSurface) {
         add_pre_commit_hook::<Self, _>(surface, move |state, _dh, surface| {
+            #[cfg(feature = "udev")]
+            let mut acquire_point = None;
             let maybe_dmabuf = with_states(surface, |surface_data| {
+                #[cfg(feature = "udev")]
+                acquire_point.clone_from(
+                    &surface_data
+                        .cached_state
+                        .get::<DrmSyncobjCachedState>()
+                        .pending()
+                        .acquire_point,
+                );
                 surface_data
                     .cached_state
                     .get::<SurfaceAttributes>()
@@ -124,6 +138,21 @@ impl<BackendData: Backend> CompositorHandler for AnvilState<BackendData> {
                     })
             });
             if let Some(dmabuf) = maybe_dmabuf {
+                #[cfg(feature = "udev")]
+                if let Some(acquire_point) = acquire_point {
+                    if let Ok((blocker, source)) = acquire_point.generate_blocker() {
+                        let client = surface.client().unwrap();
+                        let res = state.handle.insert_source(source, move |_, _, data| {
+                            let dh = data.display_handle.clone();
+                            data.client_compositor_state(&client).blocker_cleared(data, &dh);
+                            Ok(())
+                        });
+                        if res.is_ok() {
+                            add_blocker(surface, blocker);
+                            return;
+                        }
+                    }
+                }
                 if let Ok((blocker, source)) = dmabuf.generate_blocker(Interest::READ) {
                     if let Some(client) = surface.client() {
                         let res = state.handle.insert_source(source, move |_, _, data| {

anvil/src/udev.rs

@@ -85,6 +85,7 @@ use smithay::{
         drm_lease::{
             DrmLease, DrmLeaseBuilder, DrmLeaseHandler, DrmLeaseRequest, DrmLeaseState, LeaseRejected,
         },
+        drm_syncobj::{supports_syncobj_eventfd, DrmSyncobjHandler, DrmSyncobjState},
     },
 };
 use smithay_drm_extras::{
@@ -124,9 +125,10 @@ pub struct UdevData {
     pub session: LibSeatSession,
     dh: DisplayHandle,
     dmabuf_state: Option<(DmabufState, DmabufGlobal)>,
-    primary_gpu: DrmNode,
+    syncobj_state: Option<DrmSyncobjState>,
+    pub primary_gpu: DrmNode,
     gpus: GpuManager<GbmGlesBackend<GlesRenderer, DrmDeviceFd>>,
-    backends: HashMap<DrmNode, BackendData>,
+    pub backends: HashMap<DrmNode, BackendData>,
     pointer_images: Vec<(xcursor::parser::Image, MemoryRenderBuffer)>,
     pointer_element: PointerElement,
     #[cfg(feature = "debug")]
@@ -247,6 +249,7 @@ pub fn run_udev() {
     let data = UdevData {
         dh: display_handle.clone(),
         dmabuf_state: None,
+        syncobj_state: None,
         session,
         primary_gpu,
         gpus,
@@ -434,6 +437,23 @@ pub fn run_udev() {
         });
     });
 
+    // Expose syncobj protocol if supported by primary GPU
+    if let Some(primary_node) = state
+        .backend_data
+        .primary_gpu
+        .node_with_type(NodeType::Primary)
+        .and_then(|x| x.ok())
+    {
+        if let Some(backend) = state.backend_data.backends.get(&primary_node) {
+            let import_device = backend.drm.device_fd().clone();
+            if supports_syncobj_eventfd(&import_device) {
+                let syncobj_state =
+                    DrmSyncobjState::new::<AnvilState<UdevData>>(&display_handle, import_device);
+                state.backend_data.syncobj_state = Some(syncobj_state);
+            }
+        }
+    }
+
     event_loop
         .handle()
         .insert_source(udev_backend, move |event, _, data| match event {
@@ -553,6 +573,13 @@ impl DrmLeaseHandler for AnvilState<UdevData> {
 
 delegate_drm_lease!(AnvilState<UdevData>);
 
+impl DrmSyncobjHandler for AnvilState<UdevData> {
+    fn drm_syncobj_state(&mut self) -> &mut DrmSyncobjState {
+        self.backend_data.syncobj_state.as_mut().unwrap()
+    }
+}
+smithay::delegate_drm_syncobj!(AnvilState<UdevData>);
+
 pub type RenderSurface = GbmBufferedSurface<GbmAllocator<DrmDeviceFd>, Option<OutputPresentationFeedback>>;
 
 pub type GbmDrmCompositor = DrmCompositor<
@@ -743,13 +770,13 @@ impl Drop for SurfaceData {
     }
 }
 
-struct BackendData {
+pub struct BackendData {
     surfaces: HashMap<crtc::Handle, SurfaceData>,
     non_desktop_connectors: Vec<(connector::Handle, crtc::Handle)>,
     leasing_global: Option<DrmLeaseState>,
     active_leases: Vec<DrmLease>,
     gbm: GbmDevice<DrmDeviceFd>,
-    drm: DrmDevice,
+    pub drm: DrmDevice,
     drm_scanner: DrmScanner,
     render_node: DrmNode,
     registration_token: RegistrationToken,

src/backend/drm/compositor/mod.rs

@@ -203,6 +203,15 @@ enum ScanoutBuffer<B: Buffer> {
     Cursor(GbmBuffer),
 }
 
+impl<B: Buffer> ScanoutBuffer<B> {
+    fn acquire_point(&self) -> Option<SyncPoint> {
+        if let Self::Wayland(buffer) = self {
+            return buffer.acquire_point().cloned().map(SyncPoint::from);
+        }
+        None
+    }
+}
+
 impl<B: Buffer> ScanoutBuffer<B> {
     #[inline]
     fn from_underlying_storage(storage: UnderlyingStorage<'_>) -> Option<Self> {
@@ -3954,7 +3963,7 @@ where
             buffer: element_config.buffer.clone(),
             damage_clips,
             plane_claim,
-            sync: None,
+            sync: element_config.buffer.buffer.acquire_point().map(|p| (p, None)),
         };
 
         let is_compatible = previous_state

src/backend/drm/device/fd.rs

@@ -7,7 +7,7 @@ use tracing::{error, info, warn};
 
 use crate::utils::{DevPath, DeviceFd};
 
-#[derive(Debug)]
+#[derive(Debug, PartialEq)]
 struct InternalDrmDeviceFd {
     fd: DeviceFd,
     privileged: bool,
@@ -33,7 +33,7 @@ impl BasicDevice for InternalDrmDeviceFd {}
 impl ControlDevice for InternalDrmDeviceFd {}
 
 /// Ref-counted file descriptor of an open drm device
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct DrmDeviceFd(Arc<InternalDrmDeviceFd>);
 
 impl AsFd for DrmDeviceFd {

src/backend/renderer/utils/wayland.rs

@@ -1,3 +1,5 @@
+#[cfg(feature = "backend_drm")]
+use crate::wayland::drm_syncobj::{DrmSyncPoint, DrmSyncobjCachedState};
 use crate::{
     backend::renderer::{buffer_dimensions, buffer_has_alpha, element::RenderElement, ImportAll, Renderer},
     utils::{Buffer as BufferCoord, Coordinate, Logical, Physical, Point, Rectangle, Scale, Size, Transform},
@@ -56,12 +58,24 @@ unsafe impl Send for RendererSurfaceState {}
 unsafe impl Sync for RendererSurfaceState {}
 
 #[derive(Debug)]
-struct InnerBuffer(WlBuffer);
+struct InnerBuffer {
+    buffer: WlBuffer,
+    #[cfg(feature = "backend_drm")]
+    acquire_point: Option<DrmSyncPoint>,
+    #[cfg(feature = "backend_drm")]
+    release_point: Option<DrmSyncPoint>,
+}
 
 impl Drop for InnerBuffer {
     #[inline]
     fn drop(&mut self) {
-        self.0.release();
+        self.buffer.release();
+        #[cfg(feature = "backend_drm")]
+        if let Some(release_point) = &self.release_point {
+            if let Err(err) = release_point.signal() {
+                tracing::error!("Failed to signal syncobj release point: {}", err);
+            }
+        }
     }
 }
 
@@ -71,12 +85,11 @@ pub struct Buffer {
     inner: Arc<InnerBuffer>,
 }
 
-impl From<WlBuffer> for Buffer {
-    #[inline]
-    fn from(buffer: WlBuffer) -> Self {
-        Buffer {
-            inner: Arc::new(InnerBuffer(buffer)),
-        }
+impl Buffer {
+    #[cfg(feature = "backend_drm")]
+    #[allow(dead_code)]
+    pub(crate) fn acquire_point(&self) -> Option<&DrmSyncPoint> {
+        self.inner.acquire_point.as_ref()
     }
 }
 
@@ -85,29 +98,34 @@ impl std::ops::Deref for Buffer {
 
     #[inline]
     fn deref(&self) -> &Self::Target {
-        &self.inner.0
+        &self.inner.buffer
     }
 }
 
 impl PartialEq<WlBuffer> for Buffer {
     #[inline]
     fn eq(&self, other: &WlBuffer) -> bool {
-        self.inner.0 == *other
+        self.inner.buffer == *other
     }
 }
 
 impl PartialEq<WlBuffer> for &Buffer {
     #[inline]
     fn eq(&self, other: &WlBuffer) -> bool {
-        self.inner.0 == *other
+        self.inner.buffer == *other
     }
 }
 
 impl RendererSurfaceState {
     #[profiling::function]
     pub(crate) fn update_buffer(&mut self, states: &SurfaceData) {
-        let mut attrs_state = states.cached_state.get::<SurfaceAttributes>();
-        let attrs = attrs_state.current();
+        #[cfg(feature = "backend_drm")]
+        let mut guard = states.cached_state.get::<DrmSyncobjCachedState>();
+        #[cfg(feature = "backend_drm")]
+        let syncobj_state = guard.current();
+
+        let mut guard = states.cached_state.get::<SurfaceAttributes>();
+        let attrs = guard.current();
         self.buffer_delta = attrs.buffer_delta.take();
 
         if let Some(delta) = self.buffer_delta {
@@ -129,7 +147,15 @@ impl RendererSurfaceState {
                 self.buffer_transform = attrs.buffer_transform.into();
 
                 if !self.buffer.as_ref().map_or(false, |b| b == buffer) {
-                    self.buffer = Some(Buffer::from(buffer));
+                    self.buffer = Some(Buffer {
+                        inner: Arc::new(InnerBuffer {
+                            buffer,
+                            #[cfg(feature = "backend_drm")]
+                            acquire_point: syncobj_state.acquire_point.take(),
+                            #[cfg(feature = "backend_drm")]
+                            release_point: syncobj_state.release_point.take(),
+                        }),
+                    });
                 }
 
                 self.textures.clear();

src/wayland/compositor/tree.rs

@@ -1,3 +1,5 @@
+#[cfg(feature = "backend_drm")]
+use crate::wayland::drm_syncobj::DrmSyncobjCachedState;
 use crate::{utils::Serial, wayland::compositor::SUBSURFACE_ROLE};
 
 use super::{
@@ -145,6 +147,21 @@ impl PrivateSurfaceData {
         if let Some(BufferAssignment::NewBuffer(buffer)) = guard.pending().buffer.take() {
             buffer.release();
         };
+        drop(guard);
+        #[cfg(feature = "backend_drm")]
+        let mut guard = my_data.public_data.cached_state.get::<DrmSyncobjCachedState>();
+        #[cfg(feature = "backend_drm")]
+        if let Some(release_point) = &guard.pending().release_point {
+            if let Err(err) = release_point.signal() {
+                tracing::error!("Failed to signal syncobj release point: {}", err);
+            }
+        }
+        #[cfg(feature = "backend_drm")]
+        if let Some(release_point) = &guard.current().release_point {
+            if let Err(err) = release_point.signal() {
+                tracing::error!("Failed to signal syncobj release point: {}", err);
+            }
+        }
 
         let hooks = my_data.destruction_hooks.clone();
         // don't hold the mutex while the hooks are invoked