unittest_bluestore_types: fix Collection using tests

We can't use a bare Collection since we get/put refs, the last put will
delete it, and the dtor asserts nref == 0 (no faking a ref and deliberately
leaking!).

Signed-off-by: Sage Weil <sage@redhat.com>

diff --git a/src/test/objectstore/test_bluestore_types.cc b/src/test/objectstore/test_bluestore_types.cc
index 6c0284c6e9a3ee99181048ac8a892e09461a3321..a4901c689d3180cbcfa45cc658cce856c914406d 100644 (file)
--- a/src/test/objectstore/test_bluestore_types.cc
+++ b/src/test/objectstore/test_bluestore_types.cc
@@ -354,7 +354,7 @@ TEST(Blob, put_ref)
   BlueStore store(g_ceph_context, "", 8192);
   BlueStore::Cache *cache = BlueStore::Cache::create(
     g_ceph_context, "lru", NULL);
-  BlueStore::Collection coll(&store, cache, coll_t());
+  BlueStore::CollectionRef coll(new BlueStore::Collection(&store, cache, coll_t()));
 
   {
     BlueStore::Blob B;
@@ -363,10 +363,10 @@ TEST(Blob, put_ref)
     bluestore_blob_t& b = B.dirty_blob();
     PExtentVector r;
     b.extents.push_back(bluestore_pextent_t(0, mas*2));
-    B.get_ref(&coll, 0, mas*2);
+    B.get_ref(coll.get(), 0, mas*2);
     ASSERT_EQ(mas * 2, B.get_referenced_bytes());
     ASSERT_TRUE(b.is_allocated(0, mas*2));
-    B.put_ref(&coll, 0, mas*2, &r);
+    B.put_ref(coll.get(), 0, mas*2, &r);
     ASSERT_EQ(0u, B.get_referenced_bytes());
     cout << "r " << r << " " << b << std::endl;
     ASSERT_EQ(1u, r.size());
@@ -385,14 +385,14 @@ TEST(Blob, put_ref)
     bluestore_blob_t& b = B.dirty_blob();
     PExtentVector r;
     b.extents.push_back(bluestore_pextent_t(123, mas*2));
-    B.get_ref(&coll, 0, mas*2);
+    B.get_ref(coll.get(), 0, mas*2);
     ASSERT_EQ(mas * 2, B.get_referenced_bytes());
-    B.put_ref(&coll, 0, mas, &r);
+    B.put_ref(coll.get(), 0, mas, &r);
     ASSERT_EQ(mas, B.get_referenced_bytes());
     cout << "r " << r << " " << b << std::endl;
     ASSERT_EQ(0u, r.size());
     ASSERT_TRUE(b.is_allocated(0, mas*2));
-    B.put_ref(&coll, mas, mas, &r);
+    B.put_ref(coll.get(), mas, mas, &r);
     ASSERT_EQ(0u, B.get_referenced_bytes());
     ASSERT_EQ(0u, B.get_referenced_bytes());
     cout << "r " << r << " " << b << std::endl;
@@ -413,21 +413,21 @@ TEST(Blob, put_ref)
     b.extents.push_back(bluestore_pextent_t(2, mas));
     b.extents.push_back(bluestore_pextent_t(3, mas));
     b.extents.push_back(bluestore_pextent_t(4, mas));
-    B.get_ref(&coll, 0, mas*4);
+    B.get_ref(coll.get(), 0, mas*4);
     ASSERT_EQ(mas * 4, B.get_referenced_bytes());
-    B.put_ref(&coll, mas, mas, &r);
+    B.put_ref(coll.get(), mas, mas, &r);
     ASSERT_EQ(mas * 3, B.get_referenced_bytes());
     cout << "r " << r << " " << b << std::endl;
     ASSERT_EQ(0u, r.size());
     ASSERT_TRUE(b.is_allocated(0, mas*4));
     ASSERT_TRUE(b.is_allocated(mas, mas));
-    B.put_ref(&coll, mas*2, mas, &r);
+    B.put_ref(coll.get(), mas*2, mas, &r);
     ASSERT_EQ(mas * 2, B.get_referenced_bytes());
     cout << "r " << r << " " << b << std::endl;
     ASSERT_EQ(0u, r.size());
     ASSERT_TRUE(b.is_allocated(mas*2, mas));
     ASSERT_TRUE(b.is_allocated(0, mas*4));
-    B.put_ref(&coll, mas*3, mas, &r);
+    B.put_ref(coll.get(), mas*3, mas, &r);
     ASSERT_EQ(mas, B.get_referenced_bytes());
     cout << "r " << r << " " << b << std::endl;
     ASSERT_EQ(2u, r.size());
@@ -454,19 +454,19 @@ TEST(Blob, put_ref)
     b.extents.push_back(bluestore_pextent_t(4, mas));
     b.extents.push_back(bluestore_pextent_t(5, mas));
     b.extents.push_back(bluestore_pextent_t(6, mas));
-    B.get_ref(&coll, 0, mas*6);
+    B.get_ref(coll.get(), 0, mas*6);
     ASSERT_EQ(mas * 6, B.get_referenced_bytes());
-    B.put_ref(&coll, mas, mas, &r);
+    B.put_ref(coll.get(), mas, mas, &r);
     ASSERT_EQ(mas * 5, B.get_referenced_bytes());
     cout << "r " << r << " " << b << std::endl;
     ASSERT_EQ(0u, r.size());
     ASSERT_TRUE(b.is_allocated(0, mas*6));
-    B.put_ref(&coll, mas*2, mas, &r);
+    B.put_ref(coll.get(), mas*2, mas, &r);
     ASSERT_EQ(mas * 4, B.get_referenced_bytes());
     cout << "r " << r << " " << b << std::endl;
     ASSERT_EQ(0u, r.size());
     ASSERT_TRUE(b.is_allocated(0, mas*6));
-    B.put_ref(&coll, mas*3, mas, &r);
+    B.put_ref(coll.get(), mas*3, mas, &r);
     ASSERT_EQ(mas * 3, B.get_referenced_bytes());
     cout << "r " << r << " " << b << std::endl;
     ASSERT_EQ(2u, r.size());
@@ -491,19 +491,19 @@ TEST(Blob, put_ref)
     bluestore_blob_t& b = B.dirty_blob();
     PExtentVector r;
     b.extents.push_back(bluestore_pextent_t(1, mas * 6));
-    B.get_ref(&coll, 0, mas*6);
+    B.get_ref(coll.get(), 0, mas*6);
     ASSERT_EQ(mas * 6, B.get_referenced_bytes());
-    B.put_ref(&coll, mas, mas, &r);
+    B.put_ref(coll.get(), mas, mas, &r);
     ASSERT_EQ(mas * 5, B.get_referenced_bytes());
     cout << "r " << r << " " << b << std::endl;
     ASSERT_EQ(0u, r.size());
     ASSERT_TRUE(b.is_allocated(0, mas*6));
-    B.put_ref(&coll, mas*2, mas, &r);
+    B.put_ref(coll.get(), mas*2, mas, &r);
     ASSERT_EQ(mas * 4, B.get_referenced_bytes());
     cout << "r " << r << " " << b << std::endl;
     ASSERT_EQ(0u, r.size());
     ASSERT_TRUE(b.is_allocated(0, mas*6));
-    B.put_ref(&coll, mas*3, mas, &r);
+    B.put_ref(coll.get(), mas*3, mas, &r);
     ASSERT_EQ(mas * 3, B.get_referenced_bytes());
     cout << "r " << r << " " << b << std::endl;
     ASSERT_EQ(1u, r.size());
@@ -526,19 +526,19 @@ TEST(Blob, put_ref)
     b.extents.push_back(bluestore_pextent_t(1, mas * 4));
     b.extents.push_back(bluestore_pextent_t(2, mas * 4));
     b.extents.push_back(bluestore_pextent_t(3, mas * 4));
-    B.get_ref(&coll, 0, mas*12);
+    B.get_ref(coll.get(), 0, mas*12);
     ASSERT_EQ(mas * 12, B.get_referenced_bytes());
-    B.put_ref(&coll, mas, mas, &r);
+    B.put_ref(coll.get(), mas, mas, &r);
     ASSERT_EQ(mas * 11, B.get_referenced_bytes());
     cout << "r " << r << " " << b << std::endl;
     ASSERT_EQ(0u, r.size());
     ASSERT_TRUE(b.is_allocated(0, mas*12));
-    B.put_ref(&coll, mas*9, mas, &r);
+    B.put_ref(coll.get(), mas*9, mas, &r);
     ASSERT_EQ(mas * 10, B.get_referenced_bytes());
     cout << "r " << r << " " << b << std::endl;
     ASSERT_EQ(0u, r.size());
     ASSERT_TRUE(b.is_allocated(0, mas*12));
-    B.put_ref(&coll, mas*2, mas*7, &r);
+    B.put_ref(coll.get(), mas*2, mas*7, &r);
     ASSERT_EQ(mas * 3, B.get_referenced_bytes());
     cout << "r " << r << " " << b << std::endl;
     ASSERT_EQ(3u, r.size());
@@ -565,19 +565,19 @@ TEST(Blob, put_ref)
     b.extents.push_back(bluestore_pextent_t(1, mas * 4));
     b.extents.push_back(bluestore_pextent_t(2, mas * 4));
     b.extents.push_back(bluestore_pextent_t(3, mas * 4));
-    B.get_ref(&coll, 0, mas*12);
+    B.get_ref(coll.get(), 0, mas*12);
     ASSERT_EQ(mas * 12, B.get_referenced_bytes());
-    B.put_ref(&coll, mas, mas, &r);
+    B.put_ref(coll.get(), mas, mas, &r);
     ASSERT_EQ(mas * 11, B.get_referenced_bytes());
     cout << "r " << r << " " << b << std::endl;
     ASSERT_EQ(0u, r.size());
     ASSERT_TRUE(b.is_allocated(0, mas*12));
-    B.put_ref(&coll, mas*9, mas, &r);
+    B.put_ref(coll.get(), mas*9, mas, &r);
     ASSERT_EQ(mas * 10, B.get_referenced_bytes());
     cout << "r " << r << " " << b << std::endl;
     ASSERT_EQ(0u, r.size());
     ASSERT_TRUE(b.is_allocated(0, mas*12));
-    B.put_ref(&coll, mas*2, mas*7, &r);
+    B.put_ref(coll.get(), mas*2, mas*7, &r);
     ASSERT_EQ(mas * 3, B.get_referenced_bytes());
     cout << "r " << r << " " << b << std::endl;
     ASSERT_EQ(3u, r.size());
@@ -594,7 +594,7 @@ TEST(Blob, put_ref)
     ASSERT_TRUE(b.extents[0].is_valid());
     ASSERT_FALSE(b.extents[1].is_valid());
     ASSERT_TRUE(b.extents[2].is_valid());
-    B.put_ref(&coll, 0, mas, &r);
+    B.put_ref(coll.get(), 0, mas, &r);
     ASSERT_EQ(mas * 2, B.get_referenced_bytes());
     cout << "r " << r << " " << b << std::endl;
     ASSERT_EQ(1u, r.size());
@@ -603,7 +603,7 @@ TEST(Blob, put_ref)
     ASSERT_EQ(2u, b.extents.size());
     ASSERT_FALSE(b.extents[0].is_valid());
     ASSERT_TRUE(b.extents[1].is_valid());
-    B.put_ref(&coll, mas*10, mas*2, &r);
+    B.put_ref(coll.get(), mas*10, mas*2, &r);
     ASSERT_EQ(mas * 0, B.get_referenced_bytes());
     cout << "r " << r << " " << b << std::endl;
     ASSERT_EQ(1u, r.size());
@@ -621,19 +621,19 @@ TEST(Blob, put_ref)
     b.extents.push_back(bluestore_pextent_t(1, mas * 4));
     b.extents.push_back(bluestore_pextent_t(2, mas * 4));
     b.extents.push_back(bluestore_pextent_t(3, mas * 4));
-    B.get_ref(&coll, 0, mas*12);
+    B.get_ref(coll.get(), 0, mas*12);
     ASSERT_EQ(mas * 12, B.get_referenced_bytes());
-    B.put_ref(&coll, mas, mas, &r);
+    B.put_ref(coll.get(), mas, mas, &r);
     ASSERT_EQ(mas * 11, B.get_referenced_bytes());
     cout << "r " << r << " " << b << std::endl;
     ASSERT_EQ(0u, r.size());
     ASSERT_TRUE(b.is_allocated(0, mas*12));
-    B.put_ref(&coll, mas*9, mas, &r);
+    B.put_ref(coll.get(), mas*9, mas, &r);
     ASSERT_EQ(mas * 10, B.get_referenced_bytes());
     cout << "r " << r << " " << b << std::endl;
     ASSERT_EQ(0u, r.size());
     ASSERT_TRUE(b.is_allocated(0, mas*12));
-    B.put_ref(&coll, mas*2, mas*7, &r);
+    B.put_ref(coll.get(), mas*2, mas*7, &r);
     ASSERT_EQ(mas * 3, B.get_referenced_bytes());
     cout << "r " << r << " " << b << std::endl;
     ASSERT_EQ(3u, r.size());
@@ -650,7 +650,7 @@ TEST(Blob, put_ref)
     ASSERT_TRUE(b.extents[0].is_valid());
     ASSERT_FALSE(b.extents[1].is_valid());
     ASSERT_TRUE(b.extents[2].is_valid());
-    B.put_ref(&coll, mas*10, mas*2, &r);
+    B.put_ref(coll.get(), mas*10, mas*2, &r);
     ASSERT_EQ(mas * 1, B.get_referenced_bytes());
     cout << "r " << r << " " << b << std::endl;
     ASSERT_EQ(1u, r.size());
@@ -659,7 +659,7 @@ TEST(Blob, put_ref)
     ASSERT_EQ(2u, b.extents.size());
     ASSERT_TRUE(b.extents[0].is_valid());
     ASSERT_FALSE(b.extents[1].is_valid());
-    B.put_ref(&coll, 0, mas, &r);
+    B.put_ref(coll.get(), 0, mas, &r);
     ASSERT_EQ(mas * 0, B.get_referenced_bytes());
     cout << "r " << r << " " << b << std::endl;
     ASSERT_EQ(1u, r.size());
@@ -675,24 +675,24 @@ TEST(Blob, put_ref)
     bluestore_blob_t& b = B.dirty_blob();
     PExtentVector r;
     b.extents.push_back(bluestore_pextent_t(1, mas * 8));
-    B.get_ref(&coll, 0, mas*8);
+    B.get_ref(coll.get(), 0, mas*8);
     ASSERT_EQ(mas * 8, B.get_referenced_bytes());
-    B.put_ref(&coll, 0, mas, &r);
+    B.put_ref(coll.get(), 0, mas, &r);
     ASSERT_EQ(mas * 7, B.get_referenced_bytes());
     cout << "r " << r << " " << b << std::endl;
     ASSERT_EQ(0u, r.size());
     ASSERT_TRUE(b.is_allocated(0, mas*8));
-    B.put_ref(&coll, mas*7, mas, &r);
+    B.put_ref(coll.get(), mas*7, mas, &r);
     ASSERT_EQ(mas * 6, B.get_referenced_bytes());
     cout << "r " << r << " " << b << std::endl;
     ASSERT_EQ(0u, r.size());
     ASSERT_TRUE(b.is_allocated(0, mas*8));
-    B.put_ref(&coll, mas*2, mas, &r);
+    B.put_ref(coll.get(), mas*2, mas, &r);
     ASSERT_EQ(mas * 5, B.get_referenced_bytes());
     cout << "r " << r << " " << b << std::endl;
     ASSERT_EQ(0u, r.size());
     ASSERT_TRUE(b.is_allocated(0, 8));
-    B.put_ref(&coll, mas*3, mas*4, &r);
+    B.put_ref(coll.get(), mas*3, mas*4, &r);
     ASSERT_EQ(mas * 1, B.get_referenced_bytes());
     ASSERT_EQ(1u, r.size());
     ASSERT_EQ(0x2001u, r[0].offset);
@@ -702,7 +702,7 @@ TEST(Blob, put_ref)
     ASSERT_EQ(2u, b.extents.size());
     ASSERT_TRUE(b.extents[0].is_valid());
     ASSERT_FALSE(b.extents[1].is_valid());
-    B.put_ref(&coll, mas, mas, &r);
+    B.put_ref(coll.get(), mas, mas, &r);
     ASSERT_EQ(mas * 0, B.get_referenced_bytes());
     cout << "r " << r << " " << b << std::endl;
     ASSERT_EQ(1u, r.size());
@@ -720,10 +720,10 @@ TEST(Blob, put_ref)
     PExtentVector r;
     b.extents.push_back(bluestore_pextent_t(0, mas*4));
     b.init_csum(Checksummer::CSUM_CRC32C, 14, mas * 4);
-    B.get_ref(&coll, 0, mas*4);
+    B.get_ref(coll.get(), 0, mas*4);
     ASSERT_EQ(mas * 4, B.get_referenced_bytes());
     ASSERT_TRUE(b.is_allocated(0, mas*4));
-    B.put_ref(&coll, 0, mas*3, &r);
+    B.put_ref(coll.get(), 0, mas*3, &r);
     ASSERT_EQ(mas * 1, B.get_referenced_bytes());
     cout << "r " << r << " " << b << std::endl;
     ASSERT_EQ(0u, r.size());
@@ -740,15 +740,15 @@ TEST(Blob, put_ref)
     b.extents.push_back(bluestore_pextent_t(bluestore_pextent_t::INVALID_OFFSET,
                                            0x13000));
     b.extents.push_back(bluestore_pextent_t(0x40118000, 0x7000));
-    B.get_ref(&coll, 0x0, 0x3800);
-    B.get_ref(&coll, 0x17c00, 0x6400);
+    B.get_ref(coll.get(), 0x0, 0x3800);
+    B.get_ref(coll.get(), 0x17c00, 0x6400);
     ASSERT_EQ(0x3800u + 0x6400u, B.get_referenced_bytes());
     b.set_flag(bluestore_blob_t::FLAG_SHARED);
     b.init_csum(Checksummer::CSUM_CRC32C, 12, 0x1e000);
 
     cout << "before: " << B << std::endl;
     PExtentVector r;
-    B.put_ref(&coll, 0x1800, 0x2000, &r);
+    B.put_ref(coll.get(), 0x1800, 0x2000, &r);
     ASSERT_EQ(0x3800u + 0x6400u - 0x2000u, B.get_referenced_bytes());
     cout << "after: " << B << std::endl;
     cout << "r " << r << std::endl;
@@ -760,11 +760,11 @@ TEST(Blob, put_ref)
     bluestore_blob_t& b = B.dirty_blob();
     b.extents.push_back(bluestore_pextent_t(1, 0x5000));
     b.extents.push_back(bluestore_pextent_t(2, 0x5000));
-    B.get_ref(&coll, 0x0, 0xa000);
+    B.get_ref(coll.get(), 0x0, 0xa000);
     ASSERT_EQ(0xa000u, B.get_referenced_bytes());
     cout << "before: " << B << std::endl;
     PExtentVector r;
-    B.put_ref(&coll, 0x8000, 0x2000, &r);
+    B.put_ref(coll.get(), 0x8000, 0x2000, &r);
     cout << "after: " << B << std::endl;
     cout << "r " << r << std::endl;
     ASSERT_EQ(0x8000u, B.get_referenced_bytes());
@@ -779,11 +779,11 @@ TEST(Blob, put_ref)
     bluestore_blob_t& b = B.dirty_blob();
     b.extents.push_back(bluestore_pextent_t(1, 0x7000));
     b.extents.push_back(bluestore_pextent_t(2, 0x7000));
-    B.get_ref(&coll, 0x0, 0xe000);
+    B.get_ref(coll.get(), 0x0, 0xe000);
     ASSERT_EQ(0xe000u, B.get_referenced_bytes());
     cout << "before: " << B << std::endl;
     PExtentVector r;
-    B.put_ref(&coll, 0, 0xb000, &r);
+    B.put_ref(coll.get(), 0, 0xb000, &r);
     ASSERT_EQ(0x3000u, B.get_referenced_bytes());
     cout << "after: " << B << std::endl;
     cout << "r " << r << std::endl;
@@ -799,18 +799,18 @@ TEST(Blob, put_ref)
     BlueStore store(g_ceph_context, "", 0x4000);
     BlueStore::Cache *cache = BlueStore::Cache::create(
       g_ceph_context, "lru", NULL);
-    BlueStore::Collection coll(&store, cache, coll_t());
+    BlueStore::CollectionRef coll(new BlueStore::Collection(&store, cache, coll_t()));
     BlueStore::Blob B;
     B.shared_blob = new BlueStore::SharedBlob(nullptr);
     B.shared_blob->get();  // hack to avoid dtor from running
     bluestore_blob_t& b = B.dirty_blob();
     b.extents.push_back(bluestore_pextent_t(1, 0x5000));
     b.extents.push_back(bluestore_pextent_t(2, 0x7000));
-    B.get_ref(&coll, 0x0, 0xc000);
+    B.get_ref(coll.get(), 0x0, 0xc000);
     ASSERT_EQ(0xc000u, B.get_referenced_bytes());
     cout << "before: " << B << std::endl;
     PExtentVector r;
-    B.put_ref(&coll, 0x2000, 0xa000, &r);
+    B.put_ref(coll.get(), 0x2000, 0xa000, &r);
     cout << "after: " << B << std::endl;
     cout << "r " << r << std::endl;
     ASSERT_EQ(0x2000u, B.get_referenced_bytes());
@@ -889,17 +889,17 @@ TEST(Blob, split)
   BlueStore store(g_ceph_context, "", 4096);
   BlueStore::Cache *cache = BlueStore::Cache::create(
     g_ceph_context, "lru", NULL);
-  BlueStore::Collection coll(&store, cache, coll_t());
+  BlueStore::CollectionRef coll(new BlueStore::Collection(&store, cache, coll_t()));
   {
     BlueStore::Blob L, R;
-    L.shared_blob = new BlueStore::SharedBlob(&coll);
+    L.shared_blob = new BlueStore::SharedBlob(coll.get());
     L.shared_blob->get();  // hack to avoid dtor from running
-    R.shared_blob = new BlueStore::SharedBlob(&coll);
+    R.shared_blob = new BlueStore::SharedBlob(coll.get());
     R.shared_blob->get();  // hack to avoid dtor from running
     L.dirty_blob().extents.emplace_back(bluestore_pextent_t(0x2000, 0x2000));
     L.dirty_blob().init_csum(Checksummer::CSUM_CRC32C, 12, 0x2000);
-    L.get_ref(&coll, 0, 0x2000);
-    L.split(&coll, 0x1000, &R);
+    L.get_ref(coll.get(), 0, 0x2000);
+    L.split(coll.get(), 0x1000, &R);
     ASSERT_EQ(0x1000u, L.get_blob().get_logical_length());
     ASSERT_EQ(4u, L.get_blob().csum_data.length());
     ASSERT_EQ(1u, L.get_blob().extents.size());
@@ -915,16 +915,16 @@ TEST(Blob, split)
   }
   {
     BlueStore::Blob L, R;
-    L.shared_blob = new BlueStore::SharedBlob(&coll);
+    L.shared_blob = new BlueStore::SharedBlob(coll.get());
     L.shared_blob->get();  // hack to avoid dtor from running
-    R.shared_blob = new BlueStore::SharedBlob(&coll);
+    R.shared_blob = new BlueStore::SharedBlob(coll.get());
     R.shared_blob->get();  // hack to avoid dtor from running
     L.dirty_blob().extents.emplace_back(bluestore_pextent_t(0x2000, 0x1000));
     L.dirty_blob().extents.emplace_back(bluestore_pextent_t(0x12000, 0x1000));
     L.dirty_blob().init_csum(Checksummer::CSUM_CRC32C, 12, 0x2000);
-    L.get_ref(&coll, 0, 0x1000);
-    L.get_ref(&coll, 0x1000, 0x1000);
-    L.split(&coll, 0x1000, &R);
+    L.get_ref(coll.get(), 0, 0x1000);
+    L.get_ref(coll.get(), 0x1000, 0x1000);
+    L.split(coll.get(), 0x1000, &R);
     ASSERT_EQ(0x1000u, L.get_blob().get_logical_length());
     ASSERT_EQ(4u, L.get_blob().csum_data.length());
     ASSERT_EQ(1u, L.get_blob().extents.size());
@@ -945,15 +945,15 @@ TEST(Blob, legacy_decode)
   BlueStore store(g_ceph_context, "", 4096);
   BlueStore::Cache *cache = BlueStore::Cache::create(
     g_ceph_context, "lru", NULL);
-  BlueStore::Collection coll(&store, cache, coll_t());
+  BlueStore::CollectionRef coll(new BlueStore::Collection(&store, cache, coll_t()));
   bufferlist bl, bl2;
   {
     BlueStore::Blob B;
-    B.shared_blob = new BlueStore::SharedBlob(&coll);
+    B.shared_blob = new BlueStore::SharedBlob(coll.get());
     B.dirty_blob().extents.emplace_back(bluestore_pextent_t(0x1, 0x2000));
     B.dirty_blob().init_csum(Checksummer::CSUM_CRC32C, 12, 0x2000);
-    B.get_ref(&coll, 0, 0xff0);
-    B.get_ref(&coll, 0x1fff, 1);
+    B.get_ref(coll.get(), 0, 0xff0);
+    B.get_ref(coll.get(), 0x1fff, 1);
 
     bluestore_extent_ref_map_t fake_ref_map;
     fake_ref_map.get(0, 0xff0);
@@ -994,18 +994,18 @@ TEST(Blob, legacy_decode)
     auto p = bl.front().begin_deep();
     auto p2 = bl2.front().begin_deep();
     BlueStore::Blob Bres, Bres2;
-    Bres.shared_blob = new BlueStore::SharedBlob(&coll);
-    Bres2.shared_blob = new BlueStore::SharedBlob(&coll);
+    Bres.shared_blob = new BlueStore::SharedBlob(coll.get());
+    Bres2.shared_blob = new BlueStore::SharedBlob(coll.get());
 
     uint64_t sbid, sbid2;
     Bres.decode(
-      &coll,
+      coll.get(),
       p,
       1, /*struct_v*/
       &sbid,
       true);
     Bres2.decode(
-      &coll,
+      coll.get(),
       p2,
       2, /*struct_v*/
       &sbid2,
@@ -1020,11 +1020,11 @@ TEST(ExtentMap, find_lextent)
 {
   BlueStore store(g_ceph_context, "", 4096);
   BlueStore::LRUCache cache(g_ceph_context);
-  BlueStore::Collection coll(&store, &cache, coll_t());
-  BlueStore::Onode onode(&coll, ghobject_t(), "");
+  BlueStore::CollectionRef coll(new BlueStore::Collection(&store, &cache, coll_t()));
+  BlueStore::Onode onode(coll.get(), ghobject_t(), "");
   BlueStore::ExtentMap em(&onode);
   BlueStore::BlobRef br(new BlueStore::Blob);
-  br->shared_blob = new BlueStore::SharedBlob(&coll);
+  br->shared_blob = new BlueStore::SharedBlob(coll.get());
 
   ASSERT_EQ(em.extent_map.end(), em.find_lextent(0));
   ASSERT_EQ(em.extent_map.end(), em.find_lextent(100));
@@ -1069,11 +1069,11 @@ TEST(ExtentMap, seek_lextent)
 {
   BlueStore store(g_ceph_context, "", 4096);
   BlueStore::LRUCache cache(g_ceph_context);
-  BlueStore::Collection coll(&store, &cache, coll_t());
-  BlueStore::Onode onode(&coll, ghobject_t(), "");
+  BlueStore::CollectionRef coll(new BlueStore::Collection(&store, &cache, coll_t()));
+  BlueStore::Onode onode(coll.get(), ghobject_t(), "");
   BlueStore::ExtentMap em(&onode);
   BlueStore::BlobRef br(new BlueStore::Blob);
-  br->shared_blob = new BlueStore::SharedBlob(&coll);
+  br->shared_blob = new BlueStore::SharedBlob(coll.get());
 
   ASSERT_EQ(em.extent_map.end(), em.seek_lextent(0));
   ASSERT_EQ(em.extent_map.end(), em.seek_lextent(100));
@@ -1118,11 +1118,11 @@ TEST(ExtentMap, has_any_lextents)
 {
   BlueStore store(g_ceph_context, "", 4096);
   BlueStore::LRUCache cache(g_ceph_context);
-  BlueStore::Collection coll(&store, &cache, coll_t());
-  BlueStore::Onode onode(&coll, ghobject_t(), "");
+  BlueStore::CollectionRef coll(new BlueStore::Collection(&store, &cache, coll_t()));
+  BlueStore::Onode onode(coll.get(), ghobject_t(), "");
   BlueStore::ExtentMap em(&onode);
   BlueStore::BlobRef b(new BlueStore::Blob);
-  b->shared_blob = new BlueStore::SharedBlob(&coll);
+  b->shared_blob = new BlueStore::SharedBlob(coll.get());
 
   ASSERT_FALSE(em.has_any_lextents(0, 0));
   ASSERT_FALSE(em.has_any_lextents(0, 1000));
@@ -1165,15 +1165,15 @@ TEST(ExtentMap, compress_extent_map)
 {
   BlueStore store(g_ceph_context, "", 4096);
   BlueStore::LRUCache cache(g_ceph_context);
-  BlueStore::Collection coll(&store, &cache, coll_t());
-  BlueStore::Onode onode(&coll, ghobject_t(), "");
+  BlueStore::CollectionRef coll(new BlueStore::Collection(&store, &cache, coll_t()));
+  BlueStore::Onode onode(coll.get(), ghobject_t(), "");
   BlueStore::ExtentMap em(&onode);
   BlueStore::BlobRef b1(new BlueStore::Blob);
   BlueStore::BlobRef b2(new BlueStore::Blob);
   BlueStore::BlobRef b3(new BlueStore::Blob);
-  b1->shared_blob = new BlueStore::SharedBlob(&coll);
-  b2->shared_blob = new BlueStore::SharedBlob(&coll);
-  b3->shared_blob = new BlueStore::SharedBlob(&coll);
+  b1->shared_blob = new BlueStore::SharedBlob(coll.get());
+  b2->shared_blob = new BlueStore::SharedBlob(coll.get());
+  b3->shared_blob = new BlueStore::SharedBlob(coll.get());
 
   em.extent_map.insert(*new BlueStore::Extent(0, 0, 100, b1));
   em.extent_map.insert(*new BlueStore::Extent(100, 0, 100, b2));
@@ -1218,8 +1218,8 @@ TEST(GarbageCollector, BasicTest)
 {
   BlueStore::LRUCache cache(g_ceph_context);
   BlueStore store(g_ceph_context, "", 4096);
-  BlueStore::Collection coll(&store, &cache, coll_t());
-  BlueStore::Onode onode(&coll, ghobject_t(), "");
+  BlueStore::CollectionRef coll(new BlueStore::Collection(&store, &cache, coll_t()));
+  BlueStore::Onode onode(coll.get(), ghobject_t(), "");
   BlueStore::ExtentMap em(&onode);
 
   BlueStore::extent_map_t old_extents;
@@ -1253,10 +1253,10 @@ TEST(GarbageCollector, BasicTest)
     BlueStore::BlobRef b2(new BlueStore::Blob);
     BlueStore::BlobRef b3(new BlueStore::Blob);
     BlueStore::BlobRef b4(new BlueStore::Blob);
-    b1->shared_blob = new BlueStore::SharedBlob(&coll);
-    b2->shared_blob = new BlueStore::SharedBlob(&coll);
-    b3->shared_blob = new BlueStore::SharedBlob(&coll);
-    b4->shared_blob = new BlueStore::SharedBlob(&coll);
+    b1->shared_blob = new BlueStore::SharedBlob(coll.get());
+    b2->shared_blob = new BlueStore::SharedBlob(coll.get());
+    b3->shared_blob = new BlueStore::SharedBlob(coll.get());
+    b4->shared_blob = new BlueStore::SharedBlob(coll.get());
     b1->dirty_blob().set_flag(bluestore_blob_t::FLAG_COMPRESSED);
     b1->dirty_blob().compressed_length_orig = 0x2000;
     b1->dirty_blob().compressed_length = 0x1000;
@@ -1265,16 +1265,16 @@ TEST(GarbageCollector, BasicTest)
     b3->dirty_blob().extents.emplace_back(2, 0x1000);
     b4->dirty_blob().extents.emplace_back(3, 0x1000);
     em.extent_map.insert(*new BlueStore::Extent(100, 100, 10, b1));
-    b1->get_ref(&coll, 100, 10);
+    b1->get_ref(coll.get(), 100, 10);
     em.extent_map.insert(*new BlueStore::Extent(200, 200, 10, b2));
-    b2->get_ref(&coll, 200, 10);
+    b2->get_ref(coll.get(), 200, 10);
     em.extent_map.insert(*new BlueStore::Extent(300, 300, 100, b4));
-    b4->get_ref(&coll, 300, 100);
+    b4->get_ref(coll.get(), 300, 100);
     em.extent_map.insert(*new BlueStore::Extent(4096, 0, 10, b3));
-    b3->get_ref(&coll, 0, 10);
+    b3->get_ref(coll.get(), 0, 10);
 
     old_extents.push_back(*new BlueStore::Extent(300, 300, 10, b1)); 
-    b1->get_ref(&coll, 300, 10);
+    b1->get_ref(coll.get(), 300, 10);
 
     saving = gc.estimate(300, 100, em, old_extents, 4096);
     ASSERT_EQ(saving, 1);
@@ -1306,8 +1306,8 @@ TEST(GarbageCollector, BasicTest)
   */  
   {
     BlueStore store(g_ceph_context, "", 0x10000);
-    BlueStore::Collection coll(&store, &cache, coll_t());
-    BlueStore::Onode onode(&coll, ghobject_t(), "");
+    BlueStore::CollectionRef coll(new BlueStore::Collection(&store, &cache, coll_t()));
+    BlueStore::Onode onode(coll.get(), ghobject_t(), "");
     BlueStore::ExtentMap em(&onode);
 
     BlueStore::extent_map_t old_extents;
@@ -1317,10 +1317,10 @@ TEST(GarbageCollector, BasicTest)
     BlueStore::BlobRef b2(new BlueStore::Blob);
     BlueStore::BlobRef b3(new BlueStore::Blob);
     BlueStore::BlobRef b4(new BlueStore::Blob);
-    b1->shared_blob = new BlueStore::SharedBlob(&coll);
-    b2->shared_blob = new BlueStore::SharedBlob(&coll);
-    b3->shared_blob = new BlueStore::SharedBlob(&coll);
-    b4->shared_blob = new BlueStore::SharedBlob(&coll);
+    b1->shared_blob = new BlueStore::SharedBlob(coll.get());
+    b2->shared_blob = new BlueStore::SharedBlob(coll.get());
+    b3->shared_blob = new BlueStore::SharedBlob(coll.get());
+    b4->shared_blob = new BlueStore::SharedBlob(coll.get());
     b1->dirty_blob().set_flag(bluestore_blob_t::FLAG_COMPRESSED);
     b1->dirty_blob().extents.emplace_back(0, 0x20000);
     b1->dirty_blob().compressed_length = 0x20000;
@@ -1330,26 +1330,26 @@ TEST(GarbageCollector, BasicTest)
     b4->dirty_blob().extents.emplace_back(3, 0x10000);
 
     em.extent_map.insert(*new BlueStore::Extent(0, 0, 0x8000, b1));
-    b1->get_ref(&coll, 0, 0x8000);
+    b1->get_ref(coll.get(), 0, 0x8000);
     em.extent_map.insert(
       *new BlueStore::Extent(0x8000, 0x8000, 0x8000, b2)); // new extent
-    b2->get_ref(&coll, 0x8000, 0x8000);
+    b2->get_ref(coll.get(), 0x8000, 0x8000);
     em.extent_map.insert(
       *new BlueStore::Extent(0x10000, 0, 0x20000, b3)); // new extent
-    b3->get_ref(&coll, 0, 0x20000);
+    b3->get_ref(coll.get(), 0, 0x20000);
     em.extent_map.insert(
       *new BlueStore::Extent(0x30000, 0, 0xf000, b4)); // new extent
-    b4->get_ref(&coll, 0, 0xf000);
+    b4->get_ref(coll.get(), 0, 0xf000);
     em.extent_map.insert(*new BlueStore::Extent(0x3f000, 0x3f000, 0x1000, b1));
-    b1->get_ref(&coll, 0x3f000, 0x1000);
+    b1->get_ref(coll.get(), 0x3f000, 0x1000);
 
     old_extents.push_back(*new BlueStore::Extent(0x8000, 0x8000, 0x8000, b1)); 
-    b1->get_ref(&coll, 0x8000, 0x8000);
+    b1->get_ref(coll.get(), 0x8000, 0x8000);
     old_extents.push_back(
       *new BlueStore::Extent(0x10000, 0x10000, 0x20000, b1));
-    b1->get_ref(&coll, 0x10000, 0x20000);
+    b1->get_ref(coll.get(), 0x10000, 0x20000);
     old_extents.push_back(*new BlueStore::Extent(0x30000, 0x30000, 0xf000, b1)); 
-    b1->get_ref(&coll, 0x30000, 0xf000);
+    b1->get_ref(coll.get(), 0x30000, 0xf000);
 
     saving = gc.estimate(0x30000, 0xf000, em, old_extents, 0x10000);
     ASSERT_EQ(saving, 2);
@@ -1382,8 +1382,8 @@ TEST(GarbageCollector, BasicTest)
     int64_t saving;
     BlueStore::BlobRef b1(new BlueStore::Blob);
     BlueStore::BlobRef b2(new BlueStore::Blob);
-    b1->shared_blob = new BlueStore::SharedBlob(&coll);
-    b2->shared_blob = new BlueStore::SharedBlob(&coll);
+    b1->shared_blob = new BlueStore::SharedBlob(coll.get());
+    b2->shared_blob = new BlueStore::SharedBlob(coll.get());
     b1->dirty_blob().set_flag(bluestore_blob_t::FLAG_COMPRESSED);
     b1->dirty_blob().extents.emplace_back(0, 0x2000);
     b1->dirty_blob().compressed_length_orig = 0x4000;
@@ -1394,13 +1394,13 @@ TEST(GarbageCollector, BasicTest)
     b2->dirty_blob().compressed_length = 0x2000;
 
     em.extent_map.insert(*new BlueStore::Extent(0, 0, 0x3000, b1));
-    b1->get_ref(&coll, 0, 0x3000);
+    b1->get_ref(coll.get(), 0, 0x3000);
     em.extent_map.insert(
       *new BlueStore::Extent(0x3000, 0, 0x4000, b2)); // new extent
-    b2->get_ref(&coll, 0, 0x4000);
+    b2->get_ref(coll.get(), 0, 0x4000);
 
     old_extents.push_back(*new BlueStore::Extent(0x3000, 0x3000, 0x1000, b1)); 
-    b1->get_ref(&coll, 0x3000, 0x1000);
+    b1->get_ref(coll.get(), 0x3000, 0x1000);
 
     saving = gc.estimate(0x3000, 0x4000, em, old_extents, 0x1000);
     ASSERT_EQ(saving, 0);
@@ -1432,8 +1432,8 @@ TEST(GarbageCollector, BasicTest)
   */  
   {
     BlueStore store(g_ceph_context, "", 0x10000);
-    BlueStore::Collection coll(&store, &cache, coll_t());
-    BlueStore::Onode onode(&coll, ghobject_t(), "");
+    BlueStore::CollectionRef coll(new BlueStore::Collection(&store, &cache, coll_t()));
+    BlueStore::Onode onode(coll.get(), ghobject_t(), "");
     BlueStore::ExtentMap em(&onode);
 
     BlueStore::extent_map_t old_extents;
@@ -1444,11 +1444,11 @@ TEST(GarbageCollector, BasicTest)
     BlueStore::BlobRef b2(new BlueStore::Blob);
     BlueStore::BlobRef b3(new BlueStore::Blob);
     BlueStore::BlobRef b4(new BlueStore::Blob);
-    b0->shared_blob = new BlueStore::SharedBlob(&coll);
-    b1->shared_blob = new BlueStore::SharedBlob(&coll);
-    b2->shared_blob = new BlueStore::SharedBlob(&coll);
-    b3->shared_blob = new BlueStore::SharedBlob(&coll);
-    b4->shared_blob = new BlueStore::SharedBlob(&coll);
+    b0->shared_blob = new BlueStore::SharedBlob(coll.get());
+    b1->shared_blob = new BlueStore::SharedBlob(coll.get());
+    b2->shared_blob = new BlueStore::SharedBlob(coll.get());
+    b3->shared_blob = new BlueStore::SharedBlob(coll.get());
+    b4->shared_blob = new BlueStore::SharedBlob(coll.get());
     b0->dirty_blob().set_flag(bluestore_blob_t::FLAG_COMPRESSED);
     b0->dirty_blob().extents.emplace_back(0, 0x10000);
     b0->dirty_blob().compressed_length_orig = 0x20000;
@@ -1462,27 +1462,27 @@ TEST(GarbageCollector, BasicTest)
     b4->dirty_blob().extents.emplace_back(3, 0x1000);
 
     em.extent_map.insert(*new BlueStore::Extent(0, 0, 0x8000, b0));
-    b0->get_ref(&coll, 0, 0x8000);
+    b0->get_ref(coll.get(), 0, 0x8000);
     em.extent_map.insert(
       *new BlueStore::Extent(0x8000, 0x8000, 0x8000, b2)); // new extent
-    b2->get_ref(&coll, 0x8000, 0x8000);
+    b2->get_ref(coll.get(), 0x8000, 0x8000);
     em.extent_map.insert(
       *new BlueStore::Extent(0x10000, 0, 0x20000, b3)); // new extent
-    b3->get_ref(&coll, 0, 0x20000);
+    b3->get_ref(coll.get(), 0, 0x20000);
     em.extent_map.insert(
       *new BlueStore::Extent(0x30000, 0, 0xf000, b4)); // new extent
-    b4->get_ref(&coll, 0, 0xf000);
+    b4->get_ref(coll.get(), 0, 0xf000);
     em.extent_map.insert(*new BlueStore::Extent(0x3f000, 0x1f000, 0x1000, b1));
-    b1->get_ref(&coll, 0x1f000, 0x1000);
+    b1->get_ref(coll.get(), 0x1f000, 0x1000);
 
     old_extents.push_back(*new BlueStore::Extent(0x8000, 0x8000, 0x8000, b0)); 
-    b0->get_ref(&coll, 0x8000, 0x8000);
+    b0->get_ref(coll.get(), 0x8000, 0x8000);
     old_extents.push_back(
       *new BlueStore::Extent(0x10000, 0x10000, 0x10000, b0)); 
-    b0->get_ref(&coll, 0x10000, 0x10000);
+    b0->get_ref(coll.get(), 0x10000, 0x10000);
     old_extents.push_back(
       *new BlueStore::Extent(0x20000, 0x00000, 0x1f000, b1)); 
-    b1->get_ref(&coll, 0x0, 0x1f000);
+    b1->get_ref(coll.get(), 0x0, 0x1f000);
 
     saving = gc.estimate(0x30000, 0xf000, em, old_extents, 0x10000);
     ASSERT_EQ(saving, 2);