diff --git a/src/protocols/LinuxDMABUF.cpp b/src/protocols/LinuxDMABUF.cpp
index 8bf95c139..a949d6a18 100644
--- a/src/protocols/LinuxDMABUF.cpp
+++ b/src/protocols/LinuxDMABUF.cpp
@@ -120,7 +120,7 @@ bool CLinuxDMABuffer::good() {
     return m_buffer && m_buffer->good();
 }
 
-CLinuxDMABUFParamsResource::CLinuxDMABUFParamsResource(SP<CZwpLinuxBufferParamsV1> resource_) : m_resource(resource_) {
+CLinuxDMABUFParamsResource::CLinuxDMABUFParamsResource(UP<CZwpLinuxBufferParamsV1>&& resource_) : m_resource(std::move(resource_)) {
     if UNLIKELY (!good())
         return;
 
@@ -215,7 +215,7 @@ void CLinuxDMABUFParamsResource::create(uint32_t id) {
         LOGM(LOG, " | plane {}: mod {} fd {} stride {} offset {}", i, m_attrs->modifier, m_attrs->fds[i], m_attrs->strides[i], m_attrs->offsets[i]);
     }
 
-    auto buf = PROTO::linuxDma->m_buffers.emplace_back(makeShared<CLinuxDMABuffer>(id, m_resource->client(), *m_attrs));
+    auto& buf = PROTO::linuxDma->m_buffers.emplace_back(makeUnique<CLinuxDMABuffer>(id, m_resource->client(), *m_attrs));
 
     if UNLIKELY (!buf->good() || !buf->m_buffer->m_success) {
         m_resource->sendFailed();
@@ -224,7 +224,7 @@ void CLinuxDMABUFParamsResource::create(uint32_t id) {
     }
 
     if (!id)
-        m_resource->sendCreated(PROTO::linuxDma->m_buffers.back()->m_buffer->m_resource->getResource());
+        m_resource->sendCreated(buf->m_buffer->m_resource->getResource());
 
     m_createdBuffer = buf;
 }
@@ -291,7 +291,8 @@ bool CLinuxDMABUFParamsResource::verify() {
     return true;
 }
 
-CLinuxDMABUFFeedbackResource::CLinuxDMABUFFeedbackResource(SP<CZwpLinuxDmabufFeedbackV1> resource_, SP<CWLSurfaceResource> surface_) : m_surface(surface_), m_resource(resource_) {
+CLinuxDMABUFFeedbackResource::CLinuxDMABUFFeedbackResource(UP<CZwpLinuxDmabufFeedbackV1>&& resource_, SP<CWLSurfaceResource> surface_) :
+    m_surface(surface_), m_resource(std::move(resource_)) {
     if UNLIKELY (!good())
         return;
 
@@ -342,7 +343,7 @@ void CLinuxDMABUFFeedbackResource::sendDefaultFeedback() {
     m_lastFeedbackWasScanout = false;
 }
 
-CLinuxDMABUFResource::CLinuxDMABUFResource(SP<CZwpLinuxDmabufV1> resource_) : m_resource(resource_) {
+CLinuxDMABUFResource::CLinuxDMABUFResource(UP<CZwpLinuxDmabufV1>&& resource_) : m_resource(std::move(resource_)) {
     if UNLIKELY (!good())
         return;
 
@@ -350,8 +351,8 @@ CLinuxDMABUFResource::CLinuxDMABUFResource(SP<CZwpLinuxDmabufV1> resource_) : m_
     m_resource->setDestroy([this](CZwpLinuxDmabufV1* r) { PROTO::linuxDma->destroyResource(this); });
 
     m_resource->setGetDefaultFeedback([](CZwpLinuxDmabufV1* r, uint32_t id) {
-        const auto RESOURCE =
-            PROTO::linuxDma->m_feedbacks.emplace_back(makeShared<CLinuxDMABUFFeedbackResource>(makeShared<CZwpLinuxDmabufFeedbackV1>(r->client(), r->version(), id), nullptr));
+        const auto& RESOURCE =
+            PROTO::linuxDma->m_feedbacks.emplace_back(makeUnique<CLinuxDMABUFFeedbackResource>(makeUnique<CZwpLinuxDmabufFeedbackV1>(r->client(), r->version(), id), nullptr));
 
         if UNLIKELY (!RESOURCE->good()) {
             r->noMemory();
@@ -361,8 +362,8 @@ CLinuxDMABUFResource::CLinuxDMABUFResource(SP<CZwpLinuxDmabufV1> resource_) : m_
     });
 
     m_resource->setGetSurfaceFeedback([](CZwpLinuxDmabufV1* r, uint32_t id, wl_resource* surf) {
-        const auto RESOURCE = PROTO::linuxDma->m_feedbacks.emplace_back(
-            makeShared<CLinuxDMABUFFeedbackResource>(makeShared<CZwpLinuxDmabufFeedbackV1>(r->client(), r->version(), id), CWLSurfaceResource::fromResource(surf)));
+        const auto& RESOURCE = PROTO::linuxDma->m_feedbacks.emplace_back(
+            makeUnique<CLinuxDMABUFFeedbackResource>(makeUnique<CZwpLinuxDmabufFeedbackV1>(r->client(), r->version(), id), CWLSurfaceResource::fromResource(surf)));
 
         if UNLIKELY (!RESOURCE->good()) {
             r->noMemory();
@@ -372,7 +373,7 @@ CLinuxDMABUFResource::CLinuxDMABUFResource(SP<CZwpLinuxDmabufV1> resource_) : m_
     });
 
     m_resource->setCreateParams([](CZwpLinuxDmabufV1* r, uint32_t id) {
-        const auto RESOURCE = PROTO::linuxDma->m_params.emplace_back(makeShared<CLinuxDMABUFParamsResource>(makeShared<CZwpLinuxBufferParamsV1>(r->client(), r->version(), id)));
+        const auto& RESOURCE = PROTO::linuxDma->m_params.emplace_back(makeUnique<CLinuxDMABUFParamsResource>(makeUnique<CZwpLinuxBufferParamsV1>(r->client(), r->version(), id)));
 
         if UNLIKELY (!RESOURCE->good()) {
             r->noMemory();
@@ -516,7 +517,7 @@ void CLinuxDMABufV1Protocol::resetFormatTable() {
 }
 
 void CLinuxDMABufV1Protocol::bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id) {
-    const auto RESOURCE = m_managers.emplace_back(makeShared<CLinuxDMABUFResource>(makeShared<CZwpLinuxDmabufV1>(client, ver, id)));
+    const auto& RESOURCE = m_managers.emplace_back(makeUnique<CLinuxDMABUFResource>(makeUnique<CZwpLinuxDmabufV1>(client, ver, id)));
 
     if UNLIKELY (!RESOURCE->good()) {
         wl_client_post_no_memory(client);
@@ -542,7 +543,7 @@ void CLinuxDMABufV1Protocol::destroyResource(CLinuxDMABuffer* resource) {
 }
 
 void CLinuxDMABufV1Protocol::updateScanoutTranche(SP<CWLSurfaceResource> surface, PHLMONITOR pMonitor) {
-    SP<CLinuxDMABUFFeedbackResource> feedbackResource;
+    WP<CLinuxDMABUFFeedbackResource> feedbackResource;
     for (auto const& f : m_feedbacks) {
         if (f->m_surface != surface)
             continue;
diff --git a/src/protocols/LinuxDMABUF.hpp b/src/protocols/LinuxDMABUF.hpp
index 7e8450e1f..ea2c9457b 100644
--- a/src/protocols/LinuxDMABUF.hpp
+++ b/src/protocols/LinuxDMABUF.hpp
@@ -59,7 +59,7 @@ class CDMABUFFormatTable {
 
 class CLinuxDMABUFParamsResource {
   public:
-    CLinuxDMABUFParamsResource(SP<CZwpLinuxBufferParamsV1> resource_);
+    CLinuxDMABUFParamsResource(UP<CZwpLinuxBufferParamsV1>&& resource_);
     ~CLinuxDMABUFParamsResource() = default;
 
     bool                         good();
@@ -70,7 +70,7 @@ class CLinuxDMABUFParamsResource {
     bool                         m_used = false;
 
   private:
-    SP<CZwpLinuxBufferParamsV1> m_resource;
+    UP<CZwpLinuxBufferParamsV1> m_resource;
 
     bool                        verify();
     bool                        commence();
@@ -78,7 +78,7 @@ class CLinuxDMABUFParamsResource {
 
 class CLinuxDMABUFFeedbackResource {
   public:
-    CLinuxDMABUFFeedbackResource(SP<CZwpLinuxDmabufFeedbackV1> resource_, SP<CWLSurfaceResource> surface_);
+    CLinuxDMABUFFeedbackResource(UP<CZwpLinuxDmabufFeedbackV1>&& resource_, SP<CWLSurfaceResource> surface_);
     ~CLinuxDMABUFFeedbackResource() = default;
 
     bool                   good();
@@ -88,7 +88,7 @@ class CLinuxDMABUFFeedbackResource {
     SP<CWLSurfaceResource> m_surface; // optional, for surface feedbacks
 
   private:
-    SP<CZwpLinuxDmabufFeedbackV1> m_resource;
+    UP<CZwpLinuxDmabufFeedbackV1> m_resource;
     bool                          m_lastFeedbackWasScanout = false;
 
     friend class CLinuxDMABufV1Protocol;
@@ -96,14 +96,14 @@ class CLinuxDMABUFFeedbackResource {
 
 class CLinuxDMABUFResource {
   public:
-    CLinuxDMABUFResource(SP<CZwpLinuxDmabufV1> resource_);
+    CLinuxDMABUFResource(UP<CZwpLinuxDmabufV1>&& resource_);
     ~CLinuxDMABUFResource() = default;
 
     bool good();
     void sendMods();
 
   private:
-    SP<CZwpLinuxDmabufV1> m_resource;
+    UP<CZwpLinuxDmabufV1> m_resource;
 };
 
 class CLinuxDMABufV1Protocol : public IWaylandProtocol {
@@ -123,10 +123,10 @@ class CLinuxDMABufV1Protocol : public IWaylandProtocol {
     void resetFormatTable();
 
     //
-    std::vector<SP<CLinuxDMABUFResource>>         m_managers;
-    std::vector<SP<CLinuxDMABUFFeedbackResource>> m_feedbacks;
-    std::vector<SP<CLinuxDMABUFParamsResource>>   m_params;
-    std::vector<SP<CLinuxDMABuffer>>              m_buffers;
+    std::vector<UP<CLinuxDMABUFResource>>         m_managers;
+    std::vector<UP<CLinuxDMABUFFeedbackResource>> m_feedbacks;
+    std::vector<UP<CLinuxDMABUFParamsResource>>   m_params;
+    std::vector<UP<CLinuxDMABuffer>>              m_buffers;
 
     UP<CDMABUFFormatTable>                        m_formatTable;
     dev_t                                         m_mainDevice;