common: switch to ceph::unique_leakable_ptr.

Signed-off-by: Radoslaw Zarzynski <rzarzyns@redhat.com>

diff --git a/src/common/buffer.cc b/src/common/buffer.cc
index 34219f7b8a46533634921676b4e0d2c0d5d78cb1..66b3f5ec85d885bcb3a9f99787fb1a64b4bbf45f 100644 (file)
--- a/src/common/buffer.cc
+++ b/src/common/buffer.cc
@@ -467,7 +467,7 @@ static ceph::spinlock debug_lock;
     _raw->nref++;
     bdout << "ptr " << this << " get " << _raw << bendl;
   }
-  buffer::ptr::ptr(const ptr& p, std::unique_ptr<raw> r)
+  buffer::ptr::ptr(const ptr& p, ceph::unique_leakable_ptr<raw> r)
     : _raw(r.release()),
       _off(p._off),
       _len(p._len)
@@ -508,7 +508,7 @@ static ceph::spinlock debug_lock;
     return *this;
   }
 
-  std::unique_ptr<buffer::raw> buffer::ptr::clone()
+  ceph::unique_leakable_ptr<buffer::raw> buffer::ptr::clone()
   {
     return _raw->clone();
   }

diff --git a/src/include/buffer.h b/src/include/buffer.h
index e3dd91948c29dbdeacaf1ae262b0c5cd426ec0e7..97bc27a10001ca0d27199c5b43a41f93eef14482 100644 (file)
--- a/src/include/buffer.h
+++ b/src/include/buffer.h
@@ -87,6 +87,26 @@ using sha1_digest_t = sha_digest_t<20>;
 
 namespace ceph {
 
+template <class T>
+struct nop_delete {
+  void operator()(T*) {}
+};
+
+// This is not unique_ptr-like smart pointer! It just signalizes ownership
+// but DOES NOT manage the resource. It WILL LEAK if not manually deleted.
+// It's rather a replacement for raw pointer than any other smart one.
+//
+// Considered options:
+//  * unique_ptr with custom deleter implemented in .cc (would provide
+//    the non-zero-cost resource management),
+//  * GSL's owner<T*> (pretty neat but would impose an extra depedency),
+//  * unique_ptr with nop deleter,
+//  * raw pointer (doesn't embed ownership enforcement - std::move).
+template <class T>
+struct unique_leakable_ptr : public std::unique_ptr<T, ceph::nop_delete<T>> {
+  using std::unique_ptr<T, ceph::nop_delete<T>>::unique_ptr;
+};
+
 namespace buffer CEPH_BUFFER_API {
   /*
    * exceptions
@@ -255,7 +275,7 @@ namespace buffer CEPH_BUFFER_API {
     ptr(const ptr& p);
     ptr(ptr&& p) noexcept;
     ptr(const ptr& p, unsigned o, unsigned l);
-    ptr(const ptr& p, std::unique_ptr<raw> r);
+    ptr(const ptr& p, ceph::unique_leakable_ptr<raw> r);
     ptr& operator= (const ptr& p);
     ptr& operator= (ptr&& p) noexcept;
     ~ptr() {
@@ -266,7 +286,7 @@ namespace buffer CEPH_BUFFER_API {
 
     bool have_raw() const { return _raw ? true:false; }
 
-    std::unique_ptr<raw> clone();
+    ceph::unique_leakable_ptr<raw> clone();
     void swap(ptr& other) noexcept;
 
     iterator begin(size_t offset=0) {
@@ -1068,7 +1088,7 @@ namespace buffer CEPH_BUFFER_API {
       _carriage = &_buffers.back();
       _len += _buffers.back().length();
     }
-    void push_back(std::unique_ptr<raw> r) {
+    void push_back(ceph::unique_leakable_ptr<raw> r) {
       push_back(r.release());
     }
 

diff --git a/src/include/buffer_raw.h b/src/include/buffer_raw.h
index e945f2043a45846a600c78a1804ac8926f6a0498..73e6b465d214d3122e150b5d0e1ba185c02caade 100644 (file)
--- a/src/include/buffer_raw.h
+++ b/src/include/buffer_raw.h
@@ -86,10 +86,10 @@ public:
       return data;
     }
     virtual raw* clone_empty() = 0;
-    std::unique_ptr<raw> clone() {
+    ceph::unique_leakable_ptr<raw> clone() {
       raw* const c = clone_empty();
       memcpy(c->data, data, len);
-      return std::unique_ptr<raw>(c);
+      return ceph::unique_leakable_ptr<raw>(c);
     }
     virtual bool is_shareable() const {
       // true if safe to reference/share the existing buffer copy