WIP OUT_FENCE_FD; always signalled in fence

Author: ids1024

src/backend/drm/compositor/mod.rs

@@ -124,14 +124,14 @@ use std::{
     collections::{HashMap, HashSet},
     fmt::Debug,
     io::ErrorKind,
-    os::unix::io::{AsFd, OwnedFd},
+    os::unix::io::{AsFd, BorrowedFd, OwnedFd},
     rc::Rc,
     sync::{Arc, Mutex},
 };
 
 use ::gbm::{BufferObject, BufferObjectFlags};
 use drm::{
-    control::{connector, crtc, framebuffer, plane, Mode, PlaneType},
+    control::{connector, crtc, Device as _, framebuffer, plane, Mode, PlaneType},
     Device, DriverCapability,
 };
 use drm_fourcc::{DrmFormat, DrmFourcc, DrmModifier};
@@ -634,7 +634,7 @@ impl<B: Framebuffer> FrameState<B> {
         let backup = current_config.clone();
         *current_config = state;
 
-        let res = surface.test_state(self.build_planes(surface, supports_fencing, true), allow_modeset);
+        let res = surface.test_state(self.build_planes(surface, supports_fencing, true, None), allow_modeset);
 
         if res.is_err() {
             // test failed, restore previous state
@@ -674,7 +674,7 @@ impl<B: Framebuffer> FrameState<B> {
         }
 
         let res = surface.test_state(
-            self.build_planes(surface, supports_fencing, allow_partial_update),
+            self.build_planes(surface, supports_fencing, allow_partial_update, None),
             allow_modeset,
         );
 
@@ -694,11 +694,14 @@ impl<B: Framebuffer> FrameState<B> {
         supports_fencing: bool,
         allow_partial_update: bool,
         event: bool,
+        out_fence_fd: &mut Option<OwnedFd>,
+        signalled_sync_file: Option<BorrowedFd<'_>>, // XXX
     ) -> Result<(), crate::backend::drm::error::Error> {
         debug_assert!(!self.planes.iter().any(|(_, state)| state.needs_test));
         surface.commit(
-            self.build_planes(surface, supports_fencing, allow_partial_update),
+            self.build_planes(surface, supports_fencing, allow_partial_update, signalled_sync_file),
             event,
+            Some(out_fence_fd),
         )
     }
 
@@ -709,11 +712,14 @@ impl<B: Framebuffer> FrameState<B> {
         supports_fencing: bool,
         allow_partial_update: bool,
         event: bool,
+        out_fence_fd: &mut Option<OwnedFd>,
+        signalled_sync_file: Option<BorrowedFd<'_>>, // XXX
     ) -> Result<(), crate::backend::drm::error::Error> {
         debug_assert!(!self.planes.iter().any(|(_, state)| state.needs_test));
         surface.page_flip(
-            self.build_planes(surface, supports_fencing, allow_partial_update),
+            self.build_planes(surface, supports_fencing, allow_partial_update, signalled_sync_file),
             event,
+            Some(out_fence_fd)
         )
     }
 
@@ -723,6 +729,7 @@ impl<B: Framebuffer> FrameState<B> {
         surface: &'a DrmSurface,
         supports_fencing: bool,
         allow_partial_update: bool,
+        signalled_sync_file: Option<BorrowedFd<'a>>, // XXX
     ) -> impl IntoIterator<Item = super::PlaneState<'a>> {
         for (_, state) in self.planes.iter_mut().filter(|(_, state)| !state.skip) {
             if let Some(config) = state.config.as_mut() {
@@ -759,10 +766,14 @@ impl<B: Framebuffer> FrameState<B> {
                     transform: config.properties.transform,
                     damage_clips: config.damage_clips.as_ref().map(|d| d.blob()),
                     fb: *config.buffer.as_ref(),
+                    // XXX
+                    fence: signalled_sync_file
+                    /*
                     fence: config
                         .sync
                         .as_ref()
                         .and_then(|(_, fence)| fence.as_ref().map(|fence| fence.as_fd())),
+                    */
                 }),
             })
     }
@@ -1514,6 +1525,8 @@ where
 
     debug_flags: DebugFlags,
     span: tracing::Span,
+
+    signalled_sync_file: Option<OwnedFd>,
 }
 
 impl<A, F, U, G> DrmCompositor<A, F, U, G>
@@ -1600,6 +1613,14 @@ where
                 })?
             && plane_has_property(&*surface, surface.plane(), "IN_FENCE_FD")?;
 
+        let mut signalled_sync_file = None;
+        if supports_fencing {
+            // XXX unwrap
+            let syncobj = surface.device_fd().create_syncobj(true).unwrap();
+            signalled_sync_file = Some(surface.device_fd().syncobj_to_fd(syncobj, true).unwrap());
+            surface.device_fd().destroy_syncobj(syncobj).unwrap();
+        }
+
         for format in color_formats {
             debug!("Testing color format: {}", format);
             match Self::find_supported_format(
@@ -1663,6 +1684,7 @@ where
                         supports_fencing,
                         debug_flags: DebugFlags::empty(),
                         span,
+                        signalled_sync_file,
                     };
 
                     return Ok(drm_renderer);
@@ -2558,16 +2580,20 @@ where
         } = self.queued_frame.take().unwrap();
 
         let allow_partial_update = prepared_frame.kind == PreparedFrameKind::Partial;
+        let mut out_fence_fd = None;
+        let signalled_sync_file = self.signalled_sync_file.as_ref().map(|x| x.as_fd());
         let flip = if self.surface.commit_pending() {
             prepared_frame
                 .frame
-                .commit(&self.surface, self.supports_fencing, allow_partial_update, true)
+                .commit(&self.surface, self.supports_fencing, allow_partial_update, true, &mut out_fence_fd, signalled_sync_file)
         } else {
             prepared_frame
                 .frame
-                .page_flip(&self.surface, self.supports_fencing, allow_partial_update, true)
+                .page_flip(&self.surface, self.supports_fencing, allow_partial_update, true, &mut out_fence_fd, signalled_sync_file)
         };
 
+        dbg!(out_fence_fd);
+
         match flip {
             Ok(_) => {
                 if prepared_frame.kind == PreparedFrameKind::Full {

src/backend/drm/surface/atomic.rs

@@ -5,7 +5,7 @@ use drm::control::{
 };
 
 use std::collections::HashSet;
-use std::os::unix::io::AsRawFd;
+use std::os::unix::io::{AsRawFd, OwnedFd};
 use std::sync::Mutex;
 use std::sync::{
     atomic::{AtomicBool, Ordering},
@@ -344,6 +344,7 @@ impl AtomicDrmSurface {
                     }),
                 }],
                 Some(pending.blob),
+                None,
             )?;
             self.fd
                 .atomic_commit(
@@ -396,6 +397,7 @@ impl AtomicDrmSurface {
                 }),
             }],
             Some(pending.blob),
+            None,
         )?;
         self.fd
             .atomic_commit(
@@ -450,6 +452,7 @@ impl AtomicDrmSurface {
                 }),
             }],
             Some(pending.blob),
+            None,
         )?;
 
         self.fd
@@ -502,6 +505,7 @@ impl AtomicDrmSurface {
                 }),
             }],
             Some(new_blob),
+            None,
         )?;
         if let Err(err) = self
             .fd
@@ -547,7 +551,7 @@ impl AtomicDrmSurface {
         let mut removed = current_conns.difference(&pending_conns);
         let mut added = pending_conns.difference(&current_conns);
 
-        let req = self.build_request(&mut added, &mut removed, &*planes, Some(pending.blob))?;
+        let req = self.build_request(&mut added, &mut removed, &*planes, Some(pending.blob), None)?;
 
         let flags = if allow_modeset {
             AtomicCommitFlags::ALLOW_MODESET | AtomicCommitFlags::TEST_ONLY
@@ -569,6 +573,7 @@ impl AtomicDrmSurface {
         &self,
         planes: impl IntoIterator<Item = PlaneState<'a>>,
         event: bool,
+        out_fence_fd: Option<&mut Option<OwnedFd>>,
     ) -> Result<(), Error> {
         if !self.active.load(Ordering::SeqCst) {
             return Err(Error::DeviceInactive);
@@ -611,7 +616,13 @@ impl AtomicDrmSurface {
 
         // test the new config and return the request if it would be accepted by the driver.
         let req = {
-            let req = self.build_request(&mut added, &mut removed, &*planes, Some(pending.blob))?;
+            let req = self.build_request(
+                &mut added,
+                &mut removed,
+                &*planes,
+                Some(pending.blob),
+                out_fence_fd,
+            )?;
 
             if let Err(err) = self.fd.atomic_commit(
                 AtomicCommitFlags::ALLOW_MODESET | AtomicCommitFlags::TEST_ONLY,
@@ -680,6 +691,7 @@ impl AtomicDrmSurface {
         &self,
         planes: impl IntoIterator<Item = PlaneState<'a>>,
         event: bool,
+        out_fence_fd: Option<&mut Option<OwnedFd>>,
     ) -> Result<(), Error> {
         if !self.active.load(Ordering::SeqCst) {
             return Err(Error::DeviceInactive);
@@ -689,7 +701,7 @@ impl AtomicDrmSurface {
         let planes = planes.into_iter().collect::<Vec<_>>();
 
         // page flips work just like commits with fewer parameters..
-        let req = self.build_request(&mut [].iter(), &mut [].iter(), &*planes, None)?;
+        let req = self.build_request(&mut [].iter(), &mut [].iter(), &*planes, None, out_fence_fd)?;
 
         // .. and without `AtomicCommitFlags::AllowModeset`.
         // If we would set anything here, that would require a modeset, this would fail,
@@ -735,6 +747,7 @@ impl AtomicDrmSurface {
         removed_connectors: &mut dyn Iterator<Item = &connector::Handle>,
         planes: impl IntoIterator<Item = &'a PlaneState<'a>>,
         blob: Option<property::Value<'static>>,
+        out_fence_fd: Option<&mut Option<OwnedFd>>,
     ) -> Result<AtomicModeReq, Error> {
         let prop_mapping = self.prop_mapping.read().unwrap();
 
@@ -781,6 +794,17 @@ impl AtomicDrmSurface {
             property::Value::Boolean(true),
         );
 
+        if let Some(out_fence_fd) = out_fence_fd {
+            if let Ok(prop) = crtc_prop_handle(&prop_mapping, self.crtc, "OUT_FENCE_PTR") {
+                // TODO Strict pointer provenance?
+                req.add_property(
+                    self.crtc,
+                    prop,
+                    property::Value::UnsignedRange(out_fence_fd as *mut _ as _),
+                );
+            }
+        }
+
         for plane_state in planes.into_iter() {
             let handle = &plane_state.handle;
 

src/backend/drm/surface/gbm.rs

@@ -399,9 +399,9 @@ where
         };
 
         let flip = if self.drm.commit_pending() {
-            self.drm.commit([plane_state], true)
+            self.drm.commit([plane_state], true, None)
         } else {
-            self.drm.page_flip([plane_state], true)
+            self.drm.page_flip([plane_state], true, None)
         };
         if flip.is_ok() {
             self.pending_fb = Some((slot, user_data));

src/backend/drm/surface/mod.rs

@@ -1,5 +1,5 @@
 use std::io;
-use std::os::unix::io::{AsFd, BorrowedFd};
+use std::os::unix::io::{AsFd, BorrowedFd, OwnedFd};
 use std::sync::atomic::Ordering;
 use std::sync::Arc;
 
@@ -352,9 +352,10 @@ impl DrmSurface {
         &self,
         planes: impl IntoIterator<Item = PlaneState<'a>>,
         event: bool,
+        out_fence_fd: Option<&mut Option<OwnedFd>>,
     ) -> Result<(), Error> {
         match &*self.internal {
-            DrmSurfaceInternal::Atomic(surf) => surf.commit(planes, event),
+            DrmSurfaceInternal::Atomic(surf) => surf.commit(planes, event, out_fence_fd),
             DrmSurfaceInternal::Legacy(surf) => {
                 let fb = ensure_legacy_planes(self, planes)?;
                 surf.commit(fb, event)
@@ -374,9 +375,10 @@ impl DrmSurface {
         &self,
         planes: impl IntoIterator<Item = PlaneState<'a>>,
         event: bool,
+        out_fence_fd: Option<&mut Option<OwnedFd>>,
     ) -> Result<(), Error> {
         match &*self.internal {
-            DrmSurfaceInternal::Atomic(surf) => surf.page_flip(planes, event),
+            DrmSurfaceInternal::Atomic(surf) => surf.page_flip(planes, event, out_fence_fd),
             DrmSurfaceInternal::Legacy(surf) => {
                 let fb = ensure_legacy_planes(self, planes)?;
                 surf.page_flip(fb, event)