fixes

src/protocols/DRMSyncobj.cpp

@@ -157,7 +157,7 @@ bool CDRMSyncobjManagerResource::good() {
 }
 
 CDRMSyncobjProtocol::CDRMSyncobjProtocol(const wl_interface* iface, const int& ver, const std::string& name) : IWaylandProtocol(iface, ver, name) {
-    drmFD = fcntl(g_pCompositor->m_iDRMFD, F_DUPFD_CLOEXEC, 0);
+    drmFD = g_pCompositor->m_iDRMFD;
 }
 
 void CDRMSyncobjProtocol::bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id) {

src/protocols/core/Compositor.cpp

@@ -414,7 +414,7 @@ void CWLSurfaceResource::commitPendingState() {
         // release the buffer if it's synchronous as update() has done everything thats needed
         // so we can let the app know we're done.
         if (current.buffer->isSynchronous()) {
-            current.buffer->sendRelease();
+            current.buffer->sendReleaseWithSurface(self.lock());
             bufferReleased = true;
         }
     }
@@ -442,7 +442,7 @@ void CWLSurfaceResource::commitPendingState() {
 
     // for async buffers, we can only release the buffer once we are unrefing it from current.
     if (previousBuffer && !previousBuffer->isSynchronous() && !bufferReleased) {
-        previousBuffer->sendRelease();
+        previousBuffer->sendReleaseWithSurface(self.lock());
         bufferReleased = true;
     }
 }

src/protocols/types/Buffer.cpp

@@ -3,3 +3,7 @@
 void IHLBuffer::sendRelease() {
     resource->sendRelease();
 }
+
+void IHLBuffer::sendReleaseWithSurface(SP<CWLSurfaceResource> surf) {
+    resource->sendReleaseWithSurface(surf);
+}

src/protocols/types/Buffer.hpp

@@ -17,6 +17,7 @@ class IHLBuffer : public Aquamarine::IBuffer {
     virtual bool                          isSynchronous()               = 0; // whether the updates to this buffer are synchronous, aka happen over cpu
     virtual bool                          good()                        = 0;
     virtual void                          sendRelease();
+    virtual void                          sendReleaseWithSurface(SP<CWLSurfaceResource>);
 
     SP<CTexture>                          texture;
     bool                                  opaque = false;

src/protocols/types/WLBuffer.cpp

@@ -1,5 +1,9 @@
 #include "WLBuffer.hpp"
 #include "Buffer.hpp"
+#include "../core/Compositor.hpp"
+#include "../DRMSyncobj.hpp"
+#include "../../helpers/sync/SyncTimeline.hpp"
+#include <xf86drm.h>
 
 CWLBufferResource::CWLBufferResource(SP<CWlBuffer> resource_) : resource(resource_) {
     if (!good())
@@ -27,6 +31,16 @@ void CWLBufferResource::sendRelease() {
     resource->sendRelease();
 }
 
+void CWLBufferResource::sendReleaseWithSurface(SP<CWLSurfaceResource> surf) {
+    sendRelease();
+
+    if (!surf->syncobj)
+        return;
+
+    if (drmSyncobjTimelineSignal(g_pCompositor->m_iDRMFD, &surf->syncobj->releaseTimeline->timeline->handle, &surf->syncobj->releasePoint, 1))
+        Debug::log(ERR, "sendReleaseWithSurface: drmSyncobjTimelineSignal failed");
+}
+
 wl_resource* CWLBufferResource::getResource() {
     return resource->resource();
 }

src/protocols/types/WLBuffer.hpp

@@ -8,6 +8,7 @@
 #include "../../helpers/signal/Signal.hpp"
 
 class IHLBuffer;
+class CWLSurfaceResource;
 
 class CWLBufferResource {
   public:
@@ -16,6 +17,7 @@ class CWLBufferResource {
 
     bool                         good();
     void                         sendRelease();
+    void                         sendReleaseWithSurface(SP<CWLSurfaceResource>);
     wl_resource*                 getResource();
 
     WP<IHLBuffer>                buffer;