test: fixup rbd tests as a side effect of reference counting

Allocate heap objects for Journal, ExclusiveLock and ObjectMap
as these classes are not reference counted. However mock objects
for these classes can be allocated on the stack as ->get() and
->put() operations are no-op.

Signed-off-by: Mahati Chamarthy <mahati.chamarthy@intel.com>
Signed-off-by: Venky Shankar <vshankar@redhat.com>

diff --git a/src/test/librbd/exclusive_lock/test_mock_PostAcquireRequest.cc b/src/test/librbd/exclusive_lock/test_mock_PostAcquireRequest.cc
index cd84c21fba47cbf4c8d2faa97457a5b55f2aeb61..b18269236a7c456399399d49812f77c74efaa7b5 100644 (file)
--- a/src/test/librbd/exclusive_lock/test_mock_PostAcquireRequest.cc
+++ b/src/test/librbd/exclusive_lock/test_mock_PostAcquireRequest.cc
@@ -376,22 +376,22 @@ TEST_F(TestMockExclusiveLockPostAcquireRequest, JournalError) {
   InSequence seq;
   expect_is_refresh_required(mock_image_ctx, false);
 
-  MockObjectMap *mock_object_map = new MockObjectMap();
+  MockObjectMap mock_object_map;
   expect_test_features(mock_image_ctx, RBD_FEATURE_OBJECT_MAP, true);
-  expect_create_object_map(mock_image_ctx, mock_object_map);
-  expect_open_object_map(mock_image_ctx, *mock_object_map, 0);
+  expect_create_object_map(mock_image_ctx, &mock_object_map);
+  expect_open_object_map(mock_image_ctx, mock_object_map, 0);
 
-  MockJournal *mock_journal = new MockJournal();
+  MockJournal mock_journal;
   MockJournalPolicy mock_journal_policy;
   expect_test_features(mock_image_ctx, RBD_FEATURE_JOURNALING,
                        mock_image_ctx.image_lock, true);
   expect_get_journal_policy(mock_image_ctx, mock_journal_policy);
   expect_journal_disabled(mock_journal_policy, false);
-  expect_create_journal(mock_image_ctx, mock_journal);
+  expect_create_journal(mock_image_ctx, &mock_journal);
   expect_handle_prepare_lock_complete(mock_image_ctx);
-  expect_open_journal(mock_image_ctx, *mock_journal, -EINVAL);
-  expect_close_journal(mock_image_ctx, *mock_journal);
-  expect_close_object_map(mock_image_ctx, *mock_object_map);
+  expect_open_journal(mock_image_ctx, mock_journal, -EINVAL);
+  expect_close_journal(mock_image_ctx, mock_journal);
+  expect_close_object_map(mock_image_ctx, mock_object_map);
 
   C_SaferCond acquire_ctx;
   C_SaferCond ctx;
@@ -414,24 +414,24 @@ TEST_F(TestMockExclusiveLockPostAcquireRequest, AllocateJournalTagError) {
   InSequence seq;
   expect_is_refresh_required(mock_image_ctx, false);
 
-  MockObjectMap *mock_object_map = new MockObjectMap();
+  MockObjectMap mock_object_map;
   expect_test_features(mock_image_ctx, RBD_FEATURE_OBJECT_MAP, true);
-  expect_create_object_map(mock_image_ctx, mock_object_map);
-  expect_open_object_map(mock_image_ctx, *mock_object_map, 0);
+  expect_create_object_map(mock_image_ctx, &mock_object_map);
+  expect_open_object_map(mock_image_ctx, mock_object_map, 0);
 
-  MockJournal *mock_journal = new MockJournal();
+  MockJournal mock_journal;
   MockJournalPolicy mock_journal_policy;
   expect_test_features(mock_image_ctx, RBD_FEATURE_JOURNALING,
                        mock_image_ctx.image_lock, true);
   expect_get_journal_policy(mock_image_ctx, mock_journal_policy);
   expect_journal_disabled(mock_journal_policy, false);
-  expect_create_journal(mock_image_ctx, mock_journal);
+  expect_create_journal(mock_image_ctx, &mock_journal);
   expect_handle_prepare_lock_complete(mock_image_ctx);
-  expect_open_journal(mock_image_ctx, *mock_journal, 0);
+  expect_open_journal(mock_image_ctx, mock_journal, 0);
   expect_get_journal_policy(mock_image_ctx, mock_journal_policy);
   expect_allocate_journal_tag(mock_image_ctx, mock_journal_policy, -EPERM);
-  expect_close_journal(mock_image_ctx, *mock_journal);
-  expect_close_object_map(mock_image_ctx, *mock_object_map);
+  expect_close_journal(mock_image_ctx, mock_journal);
+  expect_close_object_map(mock_image_ctx, mock_object_map);
 
   C_SaferCond acquire_ctx;
   C_SaferCond ctx;
@@ -454,10 +454,10 @@ TEST_F(TestMockExclusiveLockPostAcquireRequest, OpenObjectMapError) {
   InSequence seq;
   expect_is_refresh_required(mock_image_ctx, false);
 
-  MockObjectMap *mock_object_map = new MockObjectMap();
+  MockObjectMap mock_object_map;
   expect_test_features(mock_image_ctx, RBD_FEATURE_OBJECT_MAP, true);
-  expect_create_object_map(mock_image_ctx, mock_object_map);
-  expect_open_object_map(mock_image_ctx, *mock_object_map, -EINVAL);
+  expect_create_object_map(mock_image_ctx, &mock_object_map);
+  expect_open_object_map(mock_image_ctx, mock_object_map, -EINVAL);
   expect_handle_prepare_lock_complete(mock_image_ctx);
 
   C_SaferCond *acquire_ctx = new C_SaferCond();
@@ -482,10 +482,10 @@ TEST_F(TestMockExclusiveLockPostAcquireRequest, OpenObjectMapTooBig) {
   InSequence seq;
   expect_is_refresh_required(mock_image_ctx, false);
 
-  MockObjectMap *mock_object_map = new MockObjectMap();
+  MockObjectMap mock_object_map;
   expect_test_features(mock_image_ctx, RBD_FEATURE_OBJECT_MAP, true);
-  expect_create_object_map(mock_image_ctx, mock_object_map);
-  expect_open_object_map(mock_image_ctx, *mock_object_map, -EFBIG);
+  expect_create_object_map(mock_image_ctx, &mock_object_map);
+  expect_open_object_map(mock_image_ctx, mock_object_map, -EFBIG);
 
   MockJournal mock_journal;
   MockJournalPolicy mock_journal_policy;

diff --git a/src/test/librbd/exclusive_lock/test_mock_PreReleaseRequest.cc b/src/test/librbd/exclusive_lock/test_mock_PreReleaseRequest.cc
index 989e793fc734403eec44cd7f56922a2e75a905be..38110a33d0acd7321bc8a68128cbefc3d910bd5a 100644 (file)
--- a/src/test/librbd/exclusive_lock/test_mock_PreReleaseRequest.cc
+++ b/src/test/librbd/exclusive_lock/test_mock_PreReleaseRequest.cc
@@ -138,13 +138,13 @@ TEST_F(TestMockExclusiveLockPreReleaseRequest, Success) {
 
   expect_flush_notifies(mock_image_ctx);
 
-  MockJournal *mock_journal = new MockJournal();
-  mock_image_ctx.journal = mock_journal;
-  expect_close_journal(mock_image_ctx, *mock_journal, -EINVAL);
+  MockJournal mock_journal;
+  mock_image_ctx.journal = &mock_journal;
+  expect_close_journal(mock_image_ctx, mock_journal, -EINVAL);
 
-  MockObjectMap *mock_object_map = new MockObjectMap();
-  mock_image_ctx.object_map = mock_object_map;
-  expect_close_object_map(mock_image_ctx, *mock_object_map);
+  MockObjectMap mock_object_map;
+  mock_image_ctx.object_map = &mock_object_map;
+  expect_close_object_map(mock_image_ctx, mock_object_map);
 
   expect_handle_prepare_lock_complete(mock_image_ctx);
 
@@ -173,9 +173,9 @@ TEST_F(TestMockExclusiveLockPreReleaseRequest, SuccessJournalDisabled) {
 
   expect_flush_notifies(mock_image_ctx);
 
-  MockObjectMap *mock_object_map = new MockObjectMap();
-  mock_image_ctx.object_map = mock_object_map;
-  expect_close_object_map(mock_image_ctx, *mock_object_map);
+  MockObjectMap mock_object_map;
+  mock_image_ctx.object_map = &mock_object_map;
+  expect_close_object_map(mock_image_ctx, mock_object_map);
 
   expect_handle_prepare_lock_complete(mock_image_ctx);
 
@@ -228,13 +228,13 @@ TEST_F(TestMockExclusiveLockPreReleaseRequest, Blacklisted) {
 
   expect_flush_notifies(mock_image_ctx);
 
-  MockJournal *mock_journal = new MockJournal();
-  mock_image_ctx.journal = mock_journal;
-  expect_close_journal(mock_image_ctx, *mock_journal, -EBLACKLISTED);
+  MockJournal mock_journal;
+  mock_image_ctx.journal = &mock_journal;
+  expect_close_journal(mock_image_ctx, mock_journal, -EBLACKLISTED);
 
-  MockObjectMap *mock_object_map = new MockObjectMap();
-  mock_image_ctx.object_map = mock_object_map;
-  expect_close_object_map(mock_image_ctx, *mock_object_map);
+  MockObjectMap mock_object_map;
+  mock_image_ctx.object_map = &mock_object_map;
+  expect_close_object_map(mock_image_ctx, mock_object_map);
 
   expect_handle_prepare_lock_complete(mock_image_ctx);
 

diff --git a/src/test/librbd/image/test_mock_PreRemoveRequest.cc b/src/test/librbd/image/test_mock_PreRemoveRequest.cc
index 65a20db9dbee0962373c1d3f11d96eec6cb01786..a438be8f187f8f2848b7668400d54ff0a318bc28 100644 (file)
--- a/src/test/librbd/image/test_mock_PreRemoveRequest.cc
+++ b/src/test/librbd/image/test_mock_PreRemoveRequest.cc
@@ -285,17 +285,17 @@ TEST_F(TestMockImagePreRemoveRequest, ExclusiveLockTryAcquireNotLockOwner) {
 TEST_F(TestMockImagePreRemoveRequest, Force) {
   REQUIRE_FEATURE(RBD_FEATURE_EXCLUSIVE_LOCK);
 
-  MockExclusiveLock *mock_exclusive_lock = new MockExclusiveLock();
-  m_mock_imctx->exclusive_lock = mock_exclusive_lock;
+  MockExclusiveLock mock_exclusive_lock;
+  m_mock_imctx->exclusive_lock = &mock_exclusive_lock;
 
   expect_op_work_queue(*m_mock_imctx);
   expect_test_features(*m_mock_imctx);
 
   InSequence seq;
   expect_set_journal_policy(*m_mock_imctx);
-  expect_try_acquire_exclusive_lock(*m_mock_imctx, *mock_exclusive_lock,
+  expect_try_acquire_exclusive_lock(*m_mock_imctx, mock_exclusive_lock,
                                     -EINVAL);
-  expect_shut_down_exclusive_lock(*m_mock_imctx, *mock_exclusive_lock, 0);
+  expect_shut_down_exclusive_lock(*m_mock_imctx, mock_exclusive_lock, 0);
 
   MockListWatchersRequest mock_list_watchers_request;
   expect_list_image_watchers(*m_mock_imctx, mock_list_watchers_request, 0);
@@ -312,16 +312,16 @@ TEST_F(TestMockImagePreRemoveRequest, Force) {
 TEST_F(TestMockImagePreRemoveRequest, ExclusiveLockShutDownFailed) {
   REQUIRE_FEATURE(RBD_FEATURE_EXCLUSIVE_LOCK);
 
-  MockExclusiveLock *mock_exclusive_lock = new MockExclusiveLock();
-  m_mock_imctx->exclusive_lock = mock_exclusive_lock;
+  MockExclusiveLock mock_exclusive_lock;
+  m_mock_imctx->exclusive_lock = &mock_exclusive_lock;
 
   expect_op_work_queue(*m_mock_imctx);
   expect_test_features(*m_mock_imctx);
 
   InSequence seq;
   expect_set_journal_policy(*m_mock_imctx);
-  expect_try_acquire_exclusive_lock(*m_mock_imctx, *mock_exclusive_lock, -EINVAL);
-  expect_shut_down_exclusive_lock(*m_mock_imctx, *mock_exclusive_lock, -EINVAL);
+  expect_try_acquire_exclusive_lock(*m_mock_imctx, mock_exclusive_lock, -EINVAL);
+  expect_shut_down_exclusive_lock(*m_mock_imctx, mock_exclusive_lock, -EINVAL);
 
   C_SaferCond ctx;
   auto req = MockPreRemoveRequest::create(m_mock_imctx, true, &ctx);

diff --git a/src/test/librbd/image/test_mock_RefreshRequest.cc b/src/test/librbd/image/test_mock_RefreshRequest.cc
index 0f89928818c214e064151565fe158306b051e7eb..babbfe425be8105aa9779b66bed9e12a9eb48453 100644 (file)
--- a/src/test/librbd/image/test_mock_RefreshRequest.cc
+++ b/src/test/librbd/image/test_mock_RefreshRequest.cc
@@ -811,8 +811,8 @@ TEST_F(TestMockImageRefreshRequest, DisableExclusiveLock) {
   MockRefreshImageCtx mock_image_ctx(*ictx);
   MockRefreshParentRequest mock_refresh_parent_request;
 
-  MockExclusiveLock *mock_exclusive_lock = new MockExclusiveLock();
-  mock_image_ctx.exclusive_lock = mock_exclusive_lock;
+  MockExclusiveLock mock_exclusive_lock;
+  mock_image_ctx.exclusive_lock = &mock_exclusive_lock;
 
   MockObjectMap mock_object_map;
   if (ictx->test_features(RBD_FEATURE_OBJECT_MAP)) {
@@ -853,7 +853,7 @@ TEST_F(TestMockImageRefreshRequest, DisableExclusiveLock) {
   expect_apply_metadata(mock_image_ctx, 0);
   expect_get_group(mock_image_ctx, 0);
   expect_refresh_parent_is_required(mock_refresh_parent_request, false);
-  expect_shut_down_exclusive_lock(mock_image_ctx, *mock_exclusive_lock, 0);
+  expect_shut_down_exclusive_lock(mock_image_ctx, mock_exclusive_lock, 0);
 
   C_SaferCond ctx;
   MockRefreshRequest *req = new MockRefreshRequest(mock_image_ctx, false, false, &ctx);
@@ -1058,8 +1058,8 @@ TEST_F(TestMockImageRefreshRequest, DisableJournal) {
     mock_image_ctx.object_map = &mock_object_map;
   }
 
-  MockJournal *mock_journal = new MockJournal();
-  mock_image_ctx.journal = mock_journal;
+  MockJournal mock_journal;
+  mock_image_ctx.journal = &mock_journal;
 
   if (ictx->test_features(RBD_FEATURE_JOURNALING)) {
     ASSERT_EQ(0, ictx->operations->update_features(RBD_FEATURE_JOURNALING,
@@ -1083,7 +1083,7 @@ TEST_F(TestMockImageRefreshRequest, DisableJournal) {
   if (!mock_image_ctx.clone_copy_on_read) {
     expect_set_require_lock(mock_image_ctx, librbd::io::DIRECTION_READ, false);
   }
-  expect_close_journal(mock_image_ctx, *mock_journal, 0);
+  expect_close_journal(mock_image_ctx, mock_journal, 0);
   expect_unblock_writes(mock_image_ctx);
 
   C_SaferCond ctx;
@@ -1186,8 +1186,8 @@ TEST_F(TestMockImageRefreshRequest, DisableObjectMap) {
   MockExclusiveLock mock_exclusive_lock;
   mock_image_ctx.exclusive_lock = &mock_exclusive_lock;
 
-  MockObjectMap *mock_object_map = new MockObjectMap();
-  mock_image_ctx.object_map = mock_object_map;
+  MockObjectMap mock_object_map;
+  mock_image_ctx.object_map = &mock_object_map;
 
   MockJournal mock_journal;
   if (ictx->test_features(RBD_FEATURE_JOURNALING)) {
@@ -1212,7 +1212,7 @@ TEST_F(TestMockImageRefreshRequest, DisableObjectMap) {
   expect_apply_metadata(mock_image_ctx, 0);
   expect_get_group(mock_image_ctx, 0);
   expect_refresh_parent_is_required(mock_refresh_parent_request, false);
-  expect_close_object_map(mock_image_ctx, *mock_object_map, 0);
+  expect_close_object_map(mock_image_ctx, mock_object_map, 0);
 
   C_SaferCond ctx;
   MockRefreshRequest *req = new MockRefreshRequest(mock_image_ctx, false, false, &ctx);
@@ -1240,7 +1240,7 @@ TEST_F(TestMockImageRefreshRequest, OpenObjectMapError) {
   MockExclusiveLock mock_exclusive_lock;
   mock_image_ctx.exclusive_lock = &mock_exclusive_lock;
 
-  MockObjectMap *mock_object_map = new MockObjectMap();
+  MockObjectMap mock_object_map;
 
   expect_op_work_queue(mock_image_ctx);
   expect_test_features(mock_image_ctx);
@@ -1254,7 +1254,7 @@ TEST_F(TestMockImageRefreshRequest, OpenObjectMapError) {
   expect_apply_metadata(mock_image_ctx, 0);
   expect_get_group(mock_image_ctx, 0);
   expect_refresh_parent_is_required(mock_refresh_parent_request, false);
-  expect_open_object_map(mock_image_ctx, mock_object_map, -EBLACKLISTED);
+  expect_open_object_map(mock_image_ctx, &mock_object_map, -EBLACKLISTED);
 
   C_SaferCond ctx;
   MockRefreshRequest *req = new MockRefreshRequest(mock_image_ctx, false, false,
@@ -1284,7 +1284,7 @@ TEST_F(TestMockImageRefreshRequest, OpenObjectMapTooLarge) {
   MockExclusiveLock mock_exclusive_lock;
   mock_image_ctx.exclusive_lock = &mock_exclusive_lock;
 
-  MockObjectMap *mock_object_map = new MockObjectMap();
+  MockObjectMap mock_object_map;
 
   expect_op_work_queue(mock_image_ctx);
   expect_test_features(mock_image_ctx);
@@ -1298,7 +1298,7 @@ TEST_F(TestMockImageRefreshRequest, OpenObjectMapTooLarge) {
   expect_apply_metadata(mock_image_ctx, 0);
   expect_get_group(mock_image_ctx, 0);
   expect_refresh_parent_is_required(mock_refresh_parent_request, false);
-  expect_open_object_map(mock_image_ctx, mock_object_map, -EFBIG);
+  expect_open_object_map(mock_image_ctx, &mock_object_map, -EFBIG);
 
   C_SaferCond ctx;
   MockRefreshRequest *req = new MockRefreshRequest(mock_image_ctx, false, false,

diff --git a/src/test/librbd/journal/test_Replay.cc b/src/test/librbd/journal/test_Replay.cc
index 019eb4d5424b72cb2819dd32d965f7cef6f39e67..76e0cdab7c6c6d4b870e5368fc430f1c8f5f597a 100644 (file)
--- a/src/test/librbd/journal/test_Replay.cc
+++ b/src/test/librbd/journal/test_Replay.cc
@@ -65,7 +65,8 @@ public:
     C_SaferCond close_cond;
     ictx->journal->close(&close_cond);
     ASSERT_EQ(0, close_cond.wait());
-    delete ictx->journal;
+
+    ictx->journal->put();
     ictx->journal = nullptr;
 
     C_SaferCond cond;

diff --git a/src/test/librbd/mock/MockExclusiveLock.h b/src/test/librbd/mock/MockExclusiveLock.h
index efb4fa4e33ed30dacdd25785318d0bbcde31cc02..2bf552f3b6899c82f5bc4328f1f1894d5510915a 100644 (file)
--- a/src/test/librbd/mock/MockExclusiveLock.h
+++ b/src/test/librbd/mock/MockExclusiveLock.h
@@ -4,6 +4,7 @@
 #ifndef CEPH_TEST_LIBRBD_MOCK_EXCLUSIVE_LOCK_H
 #define CEPH_TEST_LIBRBD_MOCK_EXCLUSIVE_LOCK_H
 
+#include "common/RefCountedObj.h"
 #include "include/int_types.h"
 #include "include/rados/librados.hpp"
 #include "librbd/exclusive_lock/Policy.h"
@@ -34,6 +35,9 @@ struct MockExclusiveLock {
   MOCK_METHOD0(get_unlocked_op_error, int());
 
   MOCK_METHOD1(start_op, Context*(int*));
+
+  void get() {}
+  void put() {}
 };
 
 } // namespace librbd

diff --git a/src/test/librbd/mock/MockJournal.h b/src/test/librbd/mock/MockJournal.h
index 31806217af165a0255bb69cf104dbbe08d3eb962..15baf790367c7927db987fa091c5a06bbbfe9225 100644 (file)
--- a/src/test/librbd/mock/MockJournal.h
+++ b/src/test/librbd/mock/MockJournal.h
@@ -4,6 +4,7 @@
 #ifndef CEPH_TEST_LIBRBD_MOCK_JOURNAL_H
 #define CEPH_TEST_LIBRBD_MOCK_JOURNAL_H
 
+#include "common/RefCountedObj.h"
 #include "gmock/gmock.h"
 #include "include/rados/librados_fwd.hpp"
 #include "librbd/Journal.h"
@@ -41,6 +42,9 @@ struct MockJournal {
     s_instance = this;
   }
 
+  void get() {}
+  void put() {}
+
   MOCK_CONST_METHOD0(is_journal_ready, bool());
   MOCK_CONST_METHOD0(is_journal_replaying, bool());
   MOCK_CONST_METHOD0(is_journal_appending, bool());

diff --git a/src/test/librbd/mock/MockObjectMap.h b/src/test/librbd/mock/MockObjectMap.h
index 2692a30ff0b8555aa6afc23c97ce08658abda6cd..d72408403e8e91ed995ac5cb63cd3f9c692c4127 100644 (file)
--- a/src/test/librbd/mock/MockObjectMap.h
+++ b/src/test/librbd/mock/MockObjectMap.h
@@ -26,6 +26,9 @@ struct MockObjectMap {
   MOCK_METHOD3(aio_resize, void(uint64_t new_size, uint8_t default_object_state,
                                 Context *on_finish));
 
+  void get() {}
+  void put() {}
+
   template <typename T, void(T::*MF)(int) = &T::complete>
   bool aio_update(uint64_t snap_id, uint64_t start_object_no, uint8_t new_state,
                   const boost::optional<uint8_t> &current_state,

diff --git a/src/test/librbd/object_map/test_mock_SnapshotRemoveRequest.cc b/src/test/librbd/object_map/test_mock_SnapshotRemoveRequest.cc
index a4d79240aa05fe925c6075b2dc11c3159e970714..f02d3d3e70da862883a74e99f700cd275db97ae9 100644 (file)
--- a/src/test/librbd/object_map/test_mock_SnapshotRemoveRequest.cc
+++ b/src/test/librbd/object_map/test_mock_SnapshotRemoveRequest.cc
@@ -302,11 +302,12 @@ TEST_F(TestMockObjectMapSnapshotRemoveRequest, ScrubCleanObjects) {
 
   C_SaferCond cond_ctx1;
   {
-    librbd::ObjectMap om(*ictx, ictx->snap_id);
+    librbd::ObjectMap<> *om = new librbd::ObjectMap<>(*ictx, ictx->snap_id);
     std::shared_lock owner_locker{ictx->owner_lock};
     std::unique_lock image_locker{ictx->image_lock};
-    om.set_object_map(object_map);
-    om.aio_save(&cond_ctx1);
+    om->set_object_map(object_map);
+    om->aio_save(&cond_ctx1);
+    om->put();
   }
   ASSERT_EQ(0, cond_ctx1.wait());
   ASSERT_EQ(0, snap_create(*ictx, "snap1"));

diff --git a/src/test/librbd/operation/test_mock_DisableFeaturesRequest.cc b/src/test/librbd/operation/test_mock_DisableFeaturesRequest.cc
index a880a54afdc8f380365482b8a82a46e17ec96aa9..b437f55b7361dc364a86af343a17645951a12b26 100644 (file)
--- a/src/test/librbd/operation/test_mock_DisableFeaturesRequest.cc
+++ b/src/test/librbd/operation/test_mock_DisableFeaturesRequest.cc
@@ -292,13 +292,9 @@ TEST_F(TestMockOperationDisableFeaturesRequest, All) {
 
   MockOperationImageCtx mock_image_ctx(*ictx);
   MockExclusiveLock mock_exclusive_lock;
-  MockJournal mock_journal_stack;
-  MockJournal *mock_journal = &mock_journal_stack;
-  if (features_to_disable & RBD_FEATURE_JOURNALING) {
-    mock_journal = new MockJournal();
-  }
+  MockJournal mock_journal;
   MockObjectMap mock_object_map;
-  initialize_features(ictx, mock_image_ctx, mock_exclusive_lock, *mock_journal,
+  initialize_features(ictx, mock_image_ctx, mock_exclusive_lock, mock_journal,
                      mock_object_map);
 
   expect_verify_lock_ownership(mock_image_ctx);
@@ -444,9 +440,9 @@ TEST_F(TestMockOperationDisableFeaturesRequest, Mirroring) {
 
   MockOperationImageCtx mock_image_ctx(*ictx);
   MockExclusiveLock mock_exclusive_lock;
-  MockJournal *mock_journal = new MockJournal();
+  MockJournal mock_journal;
   MockObjectMap mock_object_map;
-  initialize_features(ictx, mock_image_ctx, mock_exclusive_lock, *mock_journal,
+  initialize_features(ictx, mock_image_ctx, mock_exclusive_lock, mock_journal,
                      mock_object_map);
 
   expect_verify_lock_ownership(mock_image_ctx);
@@ -487,9 +483,9 @@ TEST_F(TestMockOperationDisableFeaturesRequest, MirroringError) {
 
   MockOperationImageCtx mock_image_ctx(*ictx);
   MockExclusiveLock mock_exclusive_lock;
-  MockJournal *mock_journal = new MockJournal();
+  MockJournal mock_journal;
   MockObjectMap mock_object_map;
-  initialize_features(ictx, mock_image_ctx, mock_exclusive_lock, *mock_journal,
+  initialize_features(ictx, mock_image_ctx, mock_exclusive_lock, mock_journal,
                      mock_object_map);
 
   expect_verify_lock_ownership(mock_image_ctx);

diff --git a/src/test/librbd/operation/test_mock_SnapshotRollbackRequest.cc b/src/test/librbd/operation/test_mock_SnapshotRollbackRequest.cc
index 96552c4cdb69648b6015620e3c2af265f6c437ed..fa14ddb37fed2188701bba3349b552965e2c4d2f 100644 (file)
--- a/src/test/librbd/operation/test_mock_SnapshotRollbackRequest.cc
+++ b/src/test/librbd/operation/test_mock_SnapshotRollbackRequest.cc
@@ -214,10 +214,10 @@ TEST_F(TestMockOperationSnapshotRollbackRequest, Success) {
   MockOperationImageCtx mock_image_ctx(*ictx);
   MockExclusiveLock mock_exclusive_lock;
   MockJournal mock_journal;
-  MockObjectMap *mock_object_map = new MockObjectMap();
-  MockObjectMap *mock_snap_object_map = new MockObjectMap();
+  MockObjectMap mock_object_map;
+  MockObjectMap mock_snap_object_map;
   initialize_features(ictx, mock_image_ctx, mock_exclusive_lock, mock_journal,
-                      *mock_object_map);
+                      mock_object_map);
   expect_op_work_queue(mock_image_ctx);
 
   InSequence seq;
@@ -226,10 +226,10 @@ TEST_F(TestMockOperationSnapshotRollbackRequest, Success) {
   expect_block_writes(mock_image_ctx, 0);
   expect_resize(mock_image_ctx, mock_resize_request, 0);
   expect_get_flags(mock_image_ctx, 123, 0);
-  expect_get_snap_object_map(mock_image_ctx, mock_snap_object_map, 123);
-  expect_rollback_object_map(mock_image_ctx, *mock_object_map);
+  expect_get_snap_object_map(mock_image_ctx, &mock_snap_object_map, 123);
+  expect_rollback_object_map(mock_image_ctx, mock_object_map);
   expect_rollback(mock_image_ctx, 0);
-  expect_refresh_object_map(mock_image_ctx, *mock_object_map);
+  expect_refresh_object_map(mock_image_ctx, mock_object_map);
   expect_invalidate_cache(mock_image_ctx, 0);
   expect_commit_op_event(mock_image_ctx, 0);
   expect_unblock_writes(mock_image_ctx);
@@ -263,10 +263,10 @@ TEST_F(TestMockOperationSnapshotRollbackRequest, SkipResize) {
   MockOperationImageCtx mock_image_ctx(*ictx);
   MockExclusiveLock mock_exclusive_lock;
   MockJournal mock_journal;
-  MockObjectMap *mock_object_map = new MockObjectMap();
-  MockObjectMap *mock_snap_object_map = new MockObjectMap();
+  MockObjectMap mock_object_map;
+  MockObjectMap mock_snap_object_map;
   initialize_features(ictx, mock_image_ctx, mock_exclusive_lock, mock_journal,
-                      *mock_object_map);
+                      mock_object_map);
   expect_op_work_queue(mock_image_ctx);
 
   InSequence seq;
@@ -274,10 +274,10 @@ TEST_F(TestMockOperationSnapshotRollbackRequest, SkipResize) {
   expect_block_writes(mock_image_ctx, 0);
   expect_get_image_size(mock_image_ctx, 345);
   expect_get_flags(mock_image_ctx, 123, 0);
-  expect_get_snap_object_map(mock_image_ctx, mock_snap_object_map, 123);
-  expect_rollback_object_map(mock_image_ctx, *mock_object_map);
+  expect_get_snap_object_map(mock_image_ctx, &mock_snap_object_map, 123);
+  expect_rollback_object_map(mock_image_ctx, mock_object_map);
   expect_rollback(mock_image_ctx, 0);
-  expect_refresh_object_map(mock_image_ctx, *mock_object_map);
+  expect_refresh_object_map(mock_image_ctx, mock_object_map);
   expect_invalidate_cache(mock_image_ctx, 0);
   expect_commit_op_event(mock_image_ctx, 0);
   expect_unblock_writes(mock_image_ctx);
@@ -314,7 +314,7 @@ TEST_F(TestMockOperationSnapshotRollbackRequest, RollbackObjectsError) {
   MockExclusiveLock mock_exclusive_lock;
   MockJournal mock_journal;
   MockObjectMap mock_object_map;
-  MockObjectMap *mock_snap_object_map = new MockObjectMap();
+  MockObjectMap mock_snap_object_map;
   initialize_features(ictx, mock_image_ctx, mock_exclusive_lock, mock_journal,
                       mock_object_map);
   expect_op_work_queue(mock_image_ctx);
@@ -325,7 +325,7 @@ TEST_F(TestMockOperationSnapshotRollbackRequest, RollbackObjectsError) {
   expect_block_writes(mock_image_ctx, 0);
   expect_resize(mock_image_ctx, mock_resize_request, 0);
   expect_get_flags(mock_image_ctx, 123, 0);
-  expect_get_snap_object_map(mock_image_ctx, mock_snap_object_map, 123);
+  expect_get_snap_object_map(mock_image_ctx, &mock_snap_object_map, 123);
   expect_rollback_object_map(mock_image_ctx, mock_object_map);
   expect_rollback(mock_image_ctx, -EINVAL);
   expect_commit_op_event(mock_image_ctx, -EINVAL);
@@ -341,10 +341,10 @@ TEST_F(TestMockOperationSnapshotRollbackRequest, InvalidateCacheError) {
   MockOperationImageCtx mock_image_ctx(*ictx);
   MockExclusiveLock mock_exclusive_lock;
   MockJournal mock_journal;
-  MockObjectMap *mock_object_map = new MockObjectMap();
-  MockObjectMap *mock_snap_object_map = new MockObjectMap();
+  MockObjectMap mock_object_map;
+  MockObjectMap mock_snap_object_map;
   initialize_features(ictx, mock_image_ctx, mock_exclusive_lock, mock_journal,
-                      *mock_object_map);
+                      mock_object_map);
   expect_op_work_queue(mock_image_ctx);
 
   InSequence seq;
@@ -353,10 +353,10 @@ TEST_F(TestMockOperationSnapshotRollbackRequest, InvalidateCacheError) {
   expect_block_writes(mock_image_ctx, 0);
   expect_resize(mock_image_ctx, mock_resize_request, 0);
   expect_get_flags(mock_image_ctx, 123, 0);
-  expect_get_snap_object_map(mock_image_ctx, mock_snap_object_map, 123);
-  expect_rollback_object_map(mock_image_ctx, *mock_object_map);
+  expect_get_snap_object_map(mock_image_ctx, &mock_snap_object_map, 123);
+  expect_rollback_object_map(mock_image_ctx, mock_object_map);
   expect_rollback(mock_image_ctx, 0);
-  expect_refresh_object_map(mock_image_ctx, *mock_object_map);
+  expect_refresh_object_map(mock_image_ctx, mock_object_map);
   expect_invalidate_cache(mock_image_ctx, -EINVAL);
   expect_commit_op_event(mock_image_ctx, -EINVAL);
   expect_unblock_writes(mock_image_ctx);

diff --git a/src/test/librbd/test_ObjectMap.cc b/src/test/librbd/test_ObjectMap.cc
index 8e80beeacb51a19dd227db5ff65983326d789ae0..61497b2af85717b1d98319138558e2e4e82cd6f0 100644 (file)
--- a/src/test/librbd/test_ObjectMap.cc
+++ b/src/test/librbd/test_ObjectMap.cc
@@ -25,9 +25,12 @@ public:
 
   int when_open_object_map(librbd::ImageCtx *ictx) {
     C_SaferCond ctx;
-    librbd::ObjectMap<> object_map(*ictx, ictx->snap_id);
-    object_map.open(&ctx);
-    return ctx.wait();
+    librbd::ObjectMap<> *object_map = new librbd::ObjectMap<>(*ictx, ictx->snap_id);
+    object_map->open(&ctx);
+    int r = ctx.wait();
+    object_map->put();
+
+    return r;
   }
 };
 

diff --git a/src/test/librbd/test_internal.cc b/src/test/librbd/test_internal.cc
index 7e9bd9eb939ae42d3c432cfca991e00ec4b8568e..2ea2d1701fedfe78dae0e7c4db2d96e749444f0e 100644 (file)
--- a/src/test/librbd/test_internal.cc
+++ b/src/test/librbd/test_internal.cc
@@ -713,11 +713,14 @@ TEST_F(TestInternal, SnapshotCopyup)
         state = OBJECT_EXISTS_CLEAN;
       }
 
-      librbd::ObjectMap<> object_map(*ictx2, ictx2->snap_id);
+      librbd::ObjectMap<> *object_map = new librbd::ObjectMap<>(*ictx2, ictx2->snap_id);
       C_SaferCond ctx;
-      object_map.open(&ctx);
+      object_map->open(&ctx);
       ASSERT_EQ(0, ctx.wait());
-      ASSERT_EQ(state, object_map[0]);
+
+      std::shared_lock image_locker{ictx2->image_lock};
+      ASSERT_EQ(state, (*object_map)[0]);
+      object_map->put();
     }
   }
 }
@@ -799,13 +802,14 @@ TEST_F(TestInternal, SnapshotCopyupZeros)
         state = OBJECT_NONEXISTENT;
       }
 
-      librbd::ObjectMap<> object_map(*ictx2, ictx2->snap_id);
+      librbd::ObjectMap<> *object_map = new librbd::ObjectMap<>(*ictx2, ictx2->snap_id);
       C_SaferCond ctx;
-      object_map.open(&ctx);
+      object_map->open(&ctx);
       ASSERT_EQ(0, ctx.wait());
 
       std::shared_lock image_locker{ictx2->image_lock};
-      ASSERT_EQ(state, object_map[0]);
+      ASSERT_EQ(state, (*object_map)[0]);
+      object_map->put();
     }
   }
 }
@@ -886,13 +890,14 @@ TEST_F(TestInternal, SnapshotCopyupZerosMigration)
         state = OBJECT_NONEXISTENT;
       }
 
-      librbd::ObjectMap<> object_map(*ictx2, ictx2->snap_id);
+      librbd::ObjectMap<> *object_map = new librbd::ObjectMap<>(*ictx2, ictx2->snap_id);
       C_SaferCond ctx;
-      object_map.open(&ctx);
+      object_map->open(&ctx);
       ASSERT_EQ(0, ctx.wait());
 
       std::shared_lock image_locker{ictx2->image_lock};
-      ASSERT_EQ(state, object_map[0]);
+      ASSERT_EQ(state, (*object_map)[0]);
+      object_map->put();
     }
   }
 }

diff --git a/src/test/librbd/test_mock_DeepCopyRequest.cc b/src/test/librbd/test_mock_DeepCopyRequest.cc
index d888fbf3cf29154a11a1b1a32aad59495eadd64e..d198620ba7208479ba30a3589f7f5b530a35baf3 100644 (file)
--- a/src/test/librbd/test_mock_DeepCopyRequest.cc
+++ b/src/test/librbd/test_mock_DeepCopyRequest.cc
@@ -17,6 +17,7 @@
 
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
+#include <boost/scope_exit.hpp>
 
 namespace librbd {
 
@@ -242,18 +243,20 @@ TEST_F(TestMockDeepCopyRequest, SimpleCopy) {
   librbd::MockExclusiveLock mock_exclusive_lock;
   mock_dst_image_ctx.exclusive_lock = &mock_exclusive_lock;
 
-  librbd::MockObjectMap *mock_object_map =
-    is_feature_enabled(RBD_FEATURE_OBJECT_MAP) ?
-    new librbd::MockObjectMap() : nullptr;
-  mock_dst_image_ctx.object_map = mock_object_map;
+  librbd::MockObjectMap mock_object_map;
+
+  mock_dst_image_ctx.object_map = nullptr;
+  if (is_feature_enabled(RBD_FEATURE_OBJECT_MAP)) {
+    mock_dst_image_ctx.object_map = &mock_object_map;
+  }
 
   expect_test_features(mock_dst_image_ctx);
 
   InSequence seq;
   expect_copy_snapshots(mock_snapshot_copy_request, 0);
   expect_copy_image(mock_image_copy_request, 0);
-  if (mock_object_map != nullptr) {
-    expect_refresh_object_map(mock_dst_image_ctx, mock_object_map, 0);
+  if (mock_dst_image_ctx.object_map != nullptr) {
+    expect_refresh_object_map(mock_dst_image_ctx, &mock_object_map, 0);
   }
   expect_copy_metadata(mock_metadata_copy_request, 0);
 
@@ -348,18 +351,20 @@ TEST_F(TestMockDeepCopyRequest, ErrorOnCopyMetadata) {
   librbd::MockExclusiveLock mock_exclusive_lock;
   mock_dst_image_ctx.exclusive_lock = &mock_exclusive_lock;
 
-  librbd::MockObjectMap *mock_object_map =
-    is_feature_enabled(RBD_FEATURE_OBJECT_MAP) ?
-    new librbd::MockObjectMap() : nullptr;
-  mock_dst_image_ctx.object_map = mock_object_map;
+  librbd::MockObjectMap mock_object_map;
+
+  mock_dst_image_ctx.object_map = nullptr;
+  if (is_feature_enabled(RBD_FEATURE_OBJECT_MAP)) {
+    mock_dst_image_ctx.object_map = &mock_object_map;
+  }
 
   expect_test_features(mock_dst_image_ctx);
 
   InSequence seq;
   expect_copy_snapshots(mock_snapshot_copy_request, 0);
   expect_copy_image(mock_image_copy_request, 0);
-  if (mock_object_map != nullptr) {
-    expect_refresh_object_map(mock_dst_image_ctx, mock_object_map, 0);
+  if (mock_dst_image_ctx.object_map != nullptr) {
+    expect_refresh_object_map(mock_dst_image_ctx, &mock_object_map, 0);
   }
   expect_copy_metadata(mock_metadata_copy_request, -EINVAL);
 
@@ -388,19 +393,19 @@ TEST_F(TestMockDeepCopyRequest, Snap) {
   librbd::MockExclusiveLock mock_exclusive_lock;
   mock_dst_image_ctx.exclusive_lock = &mock_exclusive_lock;
 
-  librbd::MockObjectMap *mock_object_map =
-    is_feature_enabled(RBD_FEATURE_OBJECT_MAP) ?
-    new librbd::MockObjectMap() : nullptr;
-  mock_dst_image_ctx.object_map = mock_object_map;
+  librbd::MockObjectMap mock_object_map;
+  if (is_feature_enabled(RBD_FEATURE_OBJECT_MAP)) {
+    mock_dst_image_ctx.object_map = &mock_object_map;
+  }
 
   expect_test_features(mock_dst_image_ctx);
 
   InSequence seq;
   expect_copy_snapshots(mock_snapshot_copy_request, 0);
   expect_copy_image(mock_image_copy_request, 0);
-  if (mock_object_map != nullptr) {
-    expect_copy_object_map(mock_exclusive_lock, mock_object_map, 0);
-    expect_refresh_object_map(mock_dst_image_ctx, mock_object_map, 0);
+  if (mock_dst_image_ctx.object_map != nullptr) {
+    expect_copy_object_map(mock_exclusive_lock, &mock_object_map, 0);
+    expect_refresh_object_map(mock_dst_image_ctx, &mock_object_map, 0);
   }
   expect_copy_metadata(mock_metadata_copy_request, 0);
 

diff --git a/src/test/librbd/test_mock_ExclusiveLock.cc b/src/test/librbd/test_mock_ExclusiveLock.cc
index eacde946a0ba59f3863a4f6a8899ece9be92f7de..ae523acc255799b12412a12f80f563c09f30bfce 100644 (file)
--- a/src/test/librbd/test_mock_ExclusiveLock.cc
+++ b/src/test/librbd/test_mock_ExclusiveLock.cc
@@ -13,6 +13,7 @@
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include <list>
+#include <boost/scope_exit.hpp>
 
 namespace librbd {
 
@@ -164,57 +165,57 @@ public:
   typedef exclusive_lock::PostAcquireRequest<MockExclusiveLockImageCtx> MockPostAcquireRequest;
   typedef exclusive_lock::PreReleaseRequest<MockExclusiveLockImageCtx> MockPreReleaseRequest;
 
-  void expect_set_state_initializing(MockManagedLock &managed_lock) {
-    EXPECT_CALL(managed_lock, set_state_initializing());
+  void expect_set_state_initializing(MockManagedLock *managed_lock) {
+    EXPECT_CALL(*managed_lock, set_state_initializing());
   }
 
-  void expect_set_state_unlocked(MockManagedLock &managed_lock) {
-    EXPECT_CALL(managed_lock, set_state_unlocked());
+  void expect_set_state_unlocked(MockManagedLock *managed_lock) {
+    EXPECT_CALL(*managed_lock, set_state_unlocked());
   }
 
-  void expect_set_state_waiting_for_lock(MockManagedLock &managed_lock) {
-    EXPECT_CALL(managed_lock, set_state_waiting_for_lock());
+  void expect_set_state_waiting_for_lock(MockManagedLock *managed_lock) {
+    EXPECT_CALL(*managed_lock, set_state_waiting_for_lock());
   }
 
-  void expect_set_state_post_acquiring(MockManagedLock &managed_lock) {
-    EXPECT_CALL(managed_lock, set_state_post_acquiring());
+  void expect_set_state_post_acquiring(MockManagedLock *managed_lock) {
+    EXPECT_CALL(*managed_lock, set_state_post_acquiring());
   }
 
-  void expect_is_state_acquiring(MockManagedLock &managed_lock, bool ret_val) {
-    EXPECT_CALL(managed_lock, is_state_acquiring())
+  void expect_is_state_acquiring(MockManagedLock *managed_lock, bool ret_val) {
+    EXPECT_CALL(*managed_lock, is_state_acquiring())
       .WillOnce(Return(ret_val));
   }
 
-  void expect_is_state_waiting_for_lock(MockManagedLock &managed_lock,
+  void expect_is_state_waiting_for_lock(MockManagedLock *managed_lock,
                                         bool ret_val) {
-    EXPECT_CALL(managed_lock, is_state_waiting_for_lock())
+    EXPECT_CALL(*managed_lock, is_state_waiting_for_lock())
       .WillOnce(Return(ret_val));
   }
 
-  void expect_is_state_pre_releasing(MockManagedLock &managed_lock,
+  void expect_is_state_pre_releasing(MockManagedLock *managed_lock,
                                      bool ret_val) {
-    EXPECT_CALL(managed_lock, is_state_pre_releasing())
+    EXPECT_CALL(*managed_lock, is_state_pre_releasing())
       .WillOnce(Return(ret_val));
   }
 
-  void expect_is_state_releasing(MockManagedLock &managed_lock, bool ret_val) {
-    EXPECT_CALL(managed_lock, is_state_releasing())
+  void expect_is_state_releasing(MockManagedLock *managed_lock, bool ret_val) {
+    EXPECT_CALL(*managed_lock, is_state_releasing())
       .WillOnce(Return(ret_val));
   }
 
-  void expect_is_state_locked(MockManagedLock &managed_lock, bool ret_val) {
-    EXPECT_CALL(managed_lock, is_state_locked())
+  void expect_is_state_locked(MockManagedLock *managed_lock, bool ret_val) {
+    EXPECT_CALL(*managed_lock, is_state_locked())
       .WillOnce(Return(ret_val));
   }
 
-  void expect_is_state_shutdown(MockManagedLock &managed_lock, bool ret_val) {
-    EXPECT_CALL(managed_lock, is_state_shutdown())
+  void expect_is_state_shutdown(MockManagedLock *managed_lock, bool ret_val) {
+    EXPECT_CALL(*managed_lock, is_state_shutdown())
       .WillOnce(Return(ret_val));
   }
 
-  void expect_is_action_acquire_lock(MockManagedLock &managed_lock,
+  void expect_is_action_acquire_lock(MockManagedLock *managed_lock,
                                      bool ret_val) {
-    EXPECT_CALL(managed_lock, is_action_acquire_lock())
+    EXPECT_CALL(*managed_lock, is_action_acquire_lock())
       .WillOnce(Return(ret_val));
   }
 
@@ -250,7 +251,7 @@ public:
       .WillOnce(CompleteRequest(&pre_acquire_request, r));
   }
 
-  void expect_post_acquire_request(MockExclusiveLock &mock_exclusive_lock,
+  void expect_post_acquire_request(MockExclusiveLock *mock_exclusive_lock,
                                    MockPostAcquireRequest &post_acquire_request,
                                    int r) {
     EXPECT_CALL(post_acquire_request, send())
@@ -266,7 +267,7 @@ public:
   }
 
   void expect_notify_request_lock(MockExclusiveLockImageCtx &mock_image_ctx,
-                                  MockExclusiveLock &mock_exclusive_lock) {
+                                  MockExclusiveLock *mock_exclusive_lock) {
     EXPECT_CALL(*mock_image_ctx.image_watcher, notify_request_lock());
   }
 
@@ -285,8 +286,8 @@ public:
                   .WillOnce(CompleteContext(0, mock_image_ctx.image_ctx->op_work_queue));
   }
 
-  void expect_shut_down(MockManagedLock &managed_lock) {
-    EXPECT_CALL(managed_lock, shut_down(_))
+  void expect_shut_down(MockManagedLock *managed_lock) {
+    EXPECT_CALL(*managed_lock, shut_down(_))
       .WillOnce(CompleteContext(0, static_cast<ContextWQ*>(nullptr)));
   }
 
@@ -301,61 +302,61 @@ public:
   }
 
   int when_init(MockExclusiveLockImageCtx &mock_image_ctx,
-                MockExclusiveLock &exclusive_lock) {
+                MockExclusiveLock *exclusive_lock) {
     C_SaferCond ctx;
     {
       std::unique_lock owner_locker{mock_image_ctx.owner_lock};
-      exclusive_lock.init(mock_image_ctx.features, &ctx);
+      exclusive_lock->init(mock_image_ctx.features, &ctx);
     }
     return ctx.wait();
   }
 
-  int when_pre_acquire_lock_handler(MockManagedLock &managed_lock) {
+  int when_pre_acquire_lock_handler(MockManagedLock *managed_lock) {
     C_SaferCond ctx;
-    managed_lock.pre_acquire_lock_handler(&ctx);
+    managed_lock->pre_acquire_lock_handler(&ctx);
     return ctx.wait();
   }
 
-  int when_post_acquire_lock_handler(MockManagedLock &managed_lock, int r) {
+  int when_post_acquire_lock_handler(MockManagedLock *managed_lock, int r) {
     C_SaferCond ctx;
-    managed_lock.post_acquire_lock_handler(r, &ctx);
+    managed_lock->post_acquire_lock_handler(r, &ctx);
     return ctx.wait();
   }
 
-  int when_pre_release_lock_handler(MockManagedLock &managed_lock,
+  int when_pre_release_lock_handler(MockManagedLock *managed_lock,
                                     bool shutting_down) {
     C_SaferCond ctx;
-    managed_lock.pre_release_lock_handler(shutting_down, &ctx);
+    managed_lock->pre_release_lock_handler(shutting_down, &ctx);
     return ctx.wait();
   }
 
-  int when_post_release_lock_handler(MockManagedLock &managed_lock,
+  int when_post_release_lock_handler(MockManagedLock *managed_lock,
                                      bool shutting_down, int r) {
     C_SaferCond ctx;
-    managed_lock.post_release_lock_handler(shutting_down, r, &ctx);
+    managed_lock->post_release_lock_handler(shutting_down, r, &ctx);
     return ctx.wait();
   }
 
-  int when_post_reacquire_lock_handler(MockManagedLock &managed_lock, int r) {
+  int when_post_reacquire_lock_handler(MockManagedLock *managed_lock, int r) {
     C_SaferCond ctx;
-    managed_lock.post_reacquire_lock_handler(r, &ctx);
+    managed_lock->post_reacquire_lock_handler(r, &ctx);
     return ctx.wait();
   }
 
   int when_shut_down(MockExclusiveLockImageCtx &mock_image_ctx,
-                     MockExclusiveLock &exclusive_lock) {
+                     MockExclusiveLock *exclusive_lock) {
     C_SaferCond ctx;
     {
       std::unique_lock owner_locker{mock_image_ctx.owner_lock};
-      exclusive_lock.shut_down(&ctx);
+      exclusive_lock->shut_down(&ctx);
     }
     return ctx.wait();
   }
 
   bool is_lock_owner(MockExclusiveLockImageCtx &mock_image_ctx,
-                     MockExclusiveLock &exclusive_lock) {
+                     MockExclusiveLock *exclusive_lock) {
     std::shared_lock owner_locker{mock_image_ctx.owner_lock};
-    return exclusive_lock.is_lock_owner();
+    return exclusive_lock->is_lock_owner();
   }
 };
 
@@ -366,9 +367,13 @@ TEST_F(TestMockExclusiveLock, StateTransitions) {
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   MockExclusiveLockImageCtx mock_image_ctx(*ictx);
-  MockExclusiveLock exclusive_lock(mock_image_ctx);
+  MockExclusiveLock *exclusive_lock = new MockExclusiveLock(mock_image_ctx);
   expect_op_work_queue(mock_image_ctx);
 
+  BOOST_SCOPE_EXIT(&exclusive_lock) {
+    exclusive_lock->put();
+  } BOOST_SCOPE_EXIT_END
+
   InSequence seq;
   expect_set_state_initializing(exclusive_lock);
   expect_block_writes(mock_image_ctx);
@@ -430,10 +435,13 @@ TEST_F(TestMockExclusiveLock, TryLockAlreadyLocked) {
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   MockExclusiveLockImageCtx mock_image_ctx(*ictx);
-  MockExclusiveLock exclusive_lock(mock_image_ctx);
+  MockExclusiveLock *exclusive_lock = new MockExclusiveLock(mock_image_ctx);
   expect_op_work_queue(mock_image_ctx);
 
-  InSequence seq;
+  BOOST_SCOPE_EXIT(&exclusive_lock) {
+    exclusive_lock->put();
+  } BOOST_SCOPE_EXIT_END
+
   expect_set_state_initializing(exclusive_lock);
   expect_block_writes(mock_image_ctx);
   expect_set_state_unlocked(exclusive_lock);
@@ -457,9 +465,13 @@ TEST_F(TestMockExclusiveLock, TryLockError) {
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   MockExclusiveLockImageCtx mock_image_ctx(*ictx);
-  MockExclusiveLock exclusive_lock(mock_image_ctx);
+  MockExclusiveLock *exclusive_lock = new MockExclusiveLock(mock_image_ctx);
   expect_op_work_queue(mock_image_ctx);
 
+  BOOST_SCOPE_EXIT(&exclusive_lock) {
+    exclusive_lock->put();
+  } BOOST_SCOPE_EXIT_END
+
   InSequence seq;
   expect_set_state_initializing(exclusive_lock);
   expect_block_writes(mock_image_ctx);
@@ -484,9 +496,13 @@ TEST_F(TestMockExclusiveLock, AcquireLockAlreadyLocked) {
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   MockExclusiveLockImageCtx mock_image_ctx(*ictx);
-  MockExclusiveLock exclusive_lock(mock_image_ctx);
+  MockExclusiveLock *exclusive_lock = new MockExclusiveLock(mock_image_ctx);
   expect_op_work_queue(mock_image_ctx);
 
+  BOOST_SCOPE_EXIT(&exclusive_lock) {
+    exclusive_lock->put();
+  } BOOST_SCOPE_EXIT_END
+
   InSequence seq;
   expect_set_state_initializing(exclusive_lock);
   expect_block_writes(mock_image_ctx);
@@ -514,9 +530,13 @@ TEST_F(TestMockExclusiveLock, AcquireLockBusy) {
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   MockExclusiveLockImageCtx mock_image_ctx(*ictx);
-  MockExclusiveLock exclusive_lock(mock_image_ctx);
+  MockExclusiveLock *exclusive_lock = new MockExclusiveLock(mock_image_ctx);
   expect_op_work_queue(mock_image_ctx);
 
+  BOOST_SCOPE_EXIT(&exclusive_lock) {
+    exclusive_lock->put();
+  } BOOST_SCOPE_EXIT_END
+
   InSequence seq;
   expect_set_state_initializing(exclusive_lock);
   expect_block_writes(mock_image_ctx);
@@ -544,9 +564,13 @@ TEST_F(TestMockExclusiveLock, AcquireLockError) {
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   MockExclusiveLockImageCtx mock_image_ctx(*ictx);
-  MockExclusiveLock exclusive_lock(mock_image_ctx);
+  MockExclusiveLock *exclusive_lock = new MockExclusiveLock(mock_image_ctx);
   expect_op_work_queue(mock_image_ctx);
 
+  BOOST_SCOPE_EXIT(&exclusive_lock) {
+    exclusive_lock->put();
+  } BOOST_SCOPE_EXIT_END
+
   InSequence seq;
   expect_set_state_initializing(exclusive_lock);
   expect_block_writes(mock_image_ctx);
@@ -572,9 +596,13 @@ TEST_F(TestMockExclusiveLock, PostAcquireLockError) {
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   MockExclusiveLockImageCtx mock_image_ctx(*ictx);
-  MockExclusiveLock exclusive_lock(mock_image_ctx);
+  MockExclusiveLock *exclusive_lock = new MockExclusiveLock(mock_image_ctx);
   expect_op_work_queue(mock_image_ctx);
 
+  BOOST_SCOPE_EXIT(&exclusive_lock) {
+    exclusive_lock->put();
+  } BOOST_SCOPE_EXIT_END
+
   InSequence seq;
   expect_set_state_initializing(exclusive_lock);
   expect_block_writes(mock_image_ctx);
@@ -600,9 +628,13 @@ TEST_F(TestMockExclusiveLock, PreReleaseLockError) {
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   MockExclusiveLockImageCtx mock_image_ctx(*ictx);
-  MockExclusiveLock exclusive_lock(mock_image_ctx);
+  MockExclusiveLock *exclusive_lock = new MockExclusiveLock(mock_image_ctx);
   expect_op_work_queue(mock_image_ctx);
 
+  BOOST_SCOPE_EXIT(&exclusive_lock) {
+    exclusive_lock->put();
+  } BOOST_SCOPE_EXIT_END
+
   InSequence seq;
   expect_set_state_initializing(exclusive_lock);
   expect_block_writes(mock_image_ctx);
@@ -626,9 +658,13 @@ TEST_F(TestMockExclusiveLock, ReacquireLock) {
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   MockExclusiveLockImageCtx mock_image_ctx(*ictx);
-  MockExclusiveLock exclusive_lock(mock_image_ctx);
+  MockExclusiveLock *exclusive_lock = new MockExclusiveLock(mock_image_ctx);
   expect_op_work_queue(mock_image_ctx);
 
+  BOOST_SCOPE_EXIT(&exclusive_lock) {
+    exclusive_lock->put();
+  } BOOST_SCOPE_EXIT_END
+
   InSequence seq;
   expect_set_state_initializing(exclusive_lock);
   expect_block_writes(mock_image_ctx);
@@ -672,11 +708,16 @@ TEST_F(TestMockExclusiveLock, BlockRequests) {
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   MockExclusiveLockImageCtx mock_image_ctx(*ictx);
-  MockExclusiveLock exclusive_lock(mock_image_ctx);
+
+  MockExclusiveLock *exclusive_lock = new MockExclusiveLock(mock_image_ctx);
   exclusive_lock::MockPolicy mock_exclusive_lock_policy;
 
   expect_op_work_queue(mock_image_ctx);
 
+  BOOST_SCOPE_EXIT(&exclusive_lock) {
+    exclusive_lock->put();
+  } BOOST_SCOPE_EXIT_END
+
   InSequence seq;
   expect_set_state_initializing(exclusive_lock);
   expect_block_writes(mock_image_ctx);
@@ -686,17 +727,17 @@ TEST_F(TestMockExclusiveLock, BlockRequests) {
   int ret_val;
   expect_is_state_shutdown(exclusive_lock, false);
   expect_is_state_locked(exclusive_lock, true);
-  ASSERT_TRUE(exclusive_lock.accept_request(
+  ASSERT_TRUE(exclusive_lock->accept_request(
                 exclusive_lock::OPERATION_REQUEST_TYPE_GENERAL, &ret_val));
   ASSERT_EQ(0, ret_val);
 
-  exclusive_lock.block_requests(-EROFS);
+  exclusive_lock->block_requests(-EROFS);
   expect_is_state_shutdown(exclusive_lock, false);
   expect_is_state_locked(exclusive_lock, true);
   expect_accept_blocked_request(mock_image_ctx, mock_exclusive_lock_policy,
                                 exclusive_lock::OPERATION_REQUEST_TYPE_GENERAL,
                                 false);
-  ASSERT_FALSE(exclusive_lock.accept_request(
+  ASSERT_FALSE(exclusive_lock->accept_request(
                  exclusive_lock::OPERATION_REQUEST_TYPE_GENERAL, &ret_val));
   ASSERT_EQ(-EROFS, ret_val);
 
@@ -705,15 +746,15 @@ TEST_F(TestMockExclusiveLock, BlockRequests) {
   expect_accept_blocked_request(
     mock_image_ctx, mock_exclusive_lock_policy,
     exclusive_lock::OPERATION_REQUEST_TYPE_TRASH_SNAP_REMOVE, true);
-  ASSERT_TRUE(exclusive_lock.accept_request(
+  ASSERT_TRUE(exclusive_lock->accept_request(
                 exclusive_lock::OPERATION_REQUEST_TYPE_TRASH_SNAP_REMOVE,
                 &ret_val));
   ASSERT_EQ(0, ret_val);
 
-  exclusive_lock.unblock_requests();
+  exclusive_lock->unblock_requests();
   expect_is_state_shutdown(exclusive_lock, false);
   expect_is_state_locked(exclusive_lock, true);
-  ASSERT_TRUE(exclusive_lock.accept_request(
+  ASSERT_TRUE(exclusive_lock->accept_request(
                 exclusive_lock::OPERATION_REQUEST_TYPE_GENERAL, &ret_val));
   ASSERT_EQ(0, ret_val);
 }

diff --git a/src/test/librbd/test_mock_Journal.cc b/src/test/librbd/test_mock_Journal.cc
index dcc74fcc889bcbfce847c3d57980d830cc7e3049..78a7ae73ccca06a907023ba490eeaf189f2c3adf 100644 (file)
--- a/src/test/librbd/test_mock_Journal.cc
+++ b/src/test/librbd/test_mock_Journal.cc
@@ -441,32 +441,32 @@ public:
                   .WillOnce(CompleteContext(0, static_cast<ContextWQ*>(NULL)));
   }
 
-  int when_open(MockJournal &mock_journal) {
+  int when_open(MockJournal *mock_journal) {
     C_SaferCond ctx;
-    mock_journal.open(&ctx);
+    mock_journal->open(&ctx);
     return ctx.wait();
   }
 
-  int when_close(MockJournal &mock_journal) {
+  int when_close(MockJournal *mock_journal) {
     C_SaferCond ctx;
-    mock_journal.close(&ctx);
+    mock_journal->close(&ctx);
     return ctx.wait();
   }
 
   uint64_t when_append_write_event(MockJournalImageCtx &mock_image_ctx,
-                                   MockJournal &mock_journal, uint64_t length) {
+                                   MockJournal *mock_journal, uint64_t length) {
     bufferlist bl;
     bl.append_zero(length);
 
     std::shared_lock owner_locker{mock_image_ctx.owner_lock};
-    return mock_journal.append_write_event(0, length, bl, false);
+    return mock_journal->append_write_event(0, length, bl, false);
   }
 
   uint64_t when_append_io_event(MockJournalImageCtx &mock_image_ctx,
-                                MockJournal &mock_journal,
+                                MockJournal *mock_journal,
                                 int filter_ret_val) {
     std::shared_lock owner_locker{mock_image_ctx.owner_lock};
-    return mock_journal.append_io_event(
+    return mock_journal->append_io_event(
       journal::EventEntry{journal::AioFlushEvent{}}, 0, 0, false,
                           filter_ret_val);
   }
@@ -502,7 +502,7 @@ public:
   }
 
   void open_journal(MockJournalImageCtx &mock_image_ctx,
-                    MockJournal &mock_journal,
+                    MockJournal *mock_journal,
                     MockObjectDispatch& mock_object_dispatch,
                     ::journal::MockJournaler &mock_journaler,
                     MockJournalOpenRequest &mock_open_request,
@@ -530,7 +530,7 @@ public:
   }
 
   void close_journal(MockJournalImageCtx& mock_image_ctx,
-                     MockJournal &mock_journal,
+                     MockJournal *mock_journal,
                      ::journal::MockJournaler &mock_journaler) {
     expect_stop_append(mock_journaler, 0);
     expect_shut_down_object_dispatch(mock_image_ctx);
@@ -556,9 +556,13 @@ TEST_F(TestMockJournal, StateTransitions) {
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   MockJournalImageCtx mock_image_ctx(*ictx);
-  MockJournal mock_journal(mock_image_ctx);
+  MockJournal *mock_journal = new MockJournal(mock_image_ctx);
   expect_op_work_queue(mock_image_ctx);
 
+  BOOST_SCOPE_EXIT(&mock_journal) {
+    mock_journal->put();
+  } BOOST_SCOPE_EXIT_END
+
   InSequence seq;
 
   MockObjectDispatch mock_object_dispatch;
@@ -610,9 +614,13 @@ TEST_F(TestMockJournal, InitError) {
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   MockJournalImageCtx mock_image_ctx(*ictx);
-  MockJournal mock_journal(mock_image_ctx);
+  MockJournal *mock_journal = new MockJournal(mock_image_ctx);
   expect_op_work_queue(mock_image_ctx);
 
+  BOOST_SCOPE_EXIT(&mock_journal) {
+    mock_journal->put();
+  } BOOST_SCOPE_EXIT_END
+
   InSequence seq;
 
   MockObjectDispatch mock_object_dispatch;
@@ -634,9 +642,13 @@ TEST_F(TestMockJournal, ReplayCompleteError) {
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   MockJournalImageCtx mock_image_ctx(*ictx);
-  MockJournal mock_journal(mock_image_ctx);
+  MockJournal *mock_journal = new MockJournal(mock_image_ctx);
   expect_op_work_queue(mock_image_ctx);
 
+  BOOST_SCOPE_EXIT(&mock_journal) {
+    mock_journal->put();
+  } BOOST_SCOPE_EXIT_END
+
   InSequence seq;
 
   MockObjectDispatch mock_object_dispatch;
@@ -687,9 +699,13 @@ TEST_F(TestMockJournal, FlushReplayError) {
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   MockJournalImageCtx mock_image_ctx(*ictx);
-  MockJournal mock_journal(mock_image_ctx);
+  MockJournal *mock_journal = new MockJournal(mock_image_ctx);
   expect_op_work_queue(mock_image_ctx);
 
+  BOOST_SCOPE_EXIT(&mock_journal) {
+    mock_journal->put();
+  } BOOST_SCOPE_EXIT_END
+
   InSequence seq;
 
   MockObjectDispatch mock_object_dispatch;
@@ -745,9 +761,13 @@ TEST_F(TestMockJournal, CorruptEntry) {
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   MockJournalImageCtx mock_image_ctx(*ictx);
-  MockJournal mock_journal(mock_image_ctx);
+  MockJournal *mock_journal = new MockJournal(mock_image_ctx);
   expect_op_work_queue(mock_image_ctx);
 
+  BOOST_SCOPE_EXIT(&mock_journal) {
+    mock_journal->put();
+  } BOOST_SCOPE_EXIT_END
+
   InSequence seq;
 
   MockObjectDispatch mock_object_dispatch;
@@ -800,9 +820,13 @@ TEST_F(TestMockJournal, StopError) {
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   MockJournalImageCtx mock_image_ctx(*ictx);
-  MockJournal mock_journal(mock_image_ctx);
+  MockJournal *mock_journal = new MockJournal(mock_image_ctx);
   expect_op_work_queue(mock_image_ctx);
 
+  BOOST_SCOPE_EXIT(&mock_journal) {
+    mock_journal->put();
+  } BOOST_SCOPE_EXIT_END
+
   InSequence seq;
 
   MockObjectDispatch mock_object_dispatch;
@@ -839,9 +863,13 @@ TEST_F(TestMockJournal, ReplayOnDiskPreFlushError) {
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   MockJournalImageCtx mock_image_ctx(*ictx);
-  MockJournal mock_journal(mock_image_ctx);
+  MockJournal *mock_journal = new MockJournal(mock_image_ctx);
   expect_op_work_queue(mock_image_ctx);
 
+  BOOST_SCOPE_EXIT(&mock_journal) {
+    mock_journal->put();
+  } BOOST_SCOPE_EXIT_END
+
   InSequence seq;
   MockObjectDispatch mock_object_dispatch;
   expect_register_object_dispatch(mock_image_ctx, mock_object_dispatch);
@@ -892,7 +920,7 @@ TEST_F(TestMockJournal, ReplayOnDiskPreFlushError) {
   expect_set_append_batch_options(mock_image_ctx, mock_journaler, false);
 
   C_SaferCond ctx;
-  mock_journal.open(&ctx);
+  mock_journal->open(&ctx);
 
   // wait for the process callback
   {
@@ -924,9 +952,13 @@ TEST_F(TestMockJournal, ReplayOnDiskPostFlushError) {
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   MockJournalImageCtx mock_image_ctx(*ictx);
-  MockJournal mock_journal(mock_image_ctx);
+  MockJournal *mock_journal = new MockJournal(mock_image_ctx);
   expect_op_work_queue(mock_image_ctx);
 
+  BOOST_SCOPE_EXIT(&mock_journal) {
+    mock_journal->put();
+  } BOOST_SCOPE_EXIT_END
+
   InSequence seq;
 
   MockObjectDispatch mock_object_dispatch;
@@ -973,7 +1005,7 @@ TEST_F(TestMockJournal, ReplayOnDiskPostFlushError) {
   expect_set_append_batch_options(mock_image_ctx, mock_journaler, false);
 
   C_SaferCond ctx;
-  mock_journal.open(&ctx);
+  mock_journal->open(&ctx);
 
   // proceed with the flush
   {
@@ -1006,7 +1038,7 @@ TEST_F(TestMockJournal, EventAndIOCommitOrder) {
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   MockJournalImageCtx mock_image_ctx(*ictx);
-  MockJournal mock_journal(mock_image_ctx);
+  MockJournal *mock_journal = new MockJournal(mock_image_ctx);
   MockObjectDispatch mock_object_dispatch;
   ::journal::MockJournaler mock_journaler;
   MockJournalOpenRequest mock_open_request;
@@ -1014,6 +1046,7 @@ TEST_F(TestMockJournal, EventAndIOCommitOrder) {
                mock_journaler, mock_open_request);
   BOOST_SCOPE_EXIT_ALL(&) {
     close_journal(mock_image_ctx, mock_journal, mock_journaler);
+    mock_journal->put();
   };
 
   ::journal::MockFuture mock_future;
@@ -1021,26 +1054,26 @@ TEST_F(TestMockJournal, EventAndIOCommitOrder) {
   expect_append_journaler(mock_journaler);
   expect_wait_future(mock_future, &on_journal_safe1);
   ASSERT_EQ(1U, when_append_io_event(mock_image_ctx, mock_journal, 0));
-  mock_journal.get_work_queue()->drain();
+  mock_journal->get_work_queue()->drain();
 
   Context *on_journal_safe2;
   expect_append_journaler(mock_journaler);
   expect_wait_future(mock_future, &on_journal_safe2);
   ASSERT_EQ(2U, when_append_io_event(mock_image_ctx, mock_journal, 0));
-  mock_journal.get_work_queue()->drain();
+  mock_journal->get_work_queue()->drain();
 
   // commit journal event followed by IO event (standard)
   on_journal_safe1->complete(0);
   ictx->op_work_queue->drain();
   expect_future_committed(mock_journaler);
-  mock_journal.commit_io_event(1U, 0);
+  mock_journal->commit_io_event(1U, 0);
 
   // commit IO event followed by journal event (cache overwrite)
-  mock_journal.commit_io_event(2U, 0);
+  mock_journal->commit_io_event(2U, 0);
   expect_future_committed(mock_journaler);
 
   C_SaferCond event_ctx;
-  mock_journal.wait_event(2U, &event_ctx);
+  mock_journal->wait_event(2U, &event_ctx);
   on_journal_safe2->complete(0);
   ictx->op_work_queue->drain();
   ASSERT_EQ(0, event_ctx.wait());
@@ -1055,7 +1088,7 @@ TEST_F(TestMockJournal, AppendWriteEvent) {
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   MockJournalImageCtx mock_image_ctx(*ictx);
-  MockJournal mock_journal(mock_image_ctx);
+  MockJournal *mock_journal = new MockJournal(mock_image_ctx);
   MockObjectDispatch mock_object_dispatch;
   ::journal::MockJournaler mock_journaler;
   MockJournalOpenRequest mock_open_request;
@@ -1063,6 +1096,7 @@ TEST_F(TestMockJournal, AppendWriteEvent) {
                mock_journaler, mock_open_request);
   BOOST_SCOPE_EXIT_ALL(&) {
     close_journal(mock_image_ctx, mock_journal, mock_journaler);
+    mock_journal->put();
   };
 
   InSequence seq;
@@ -1074,17 +1108,17 @@ TEST_F(TestMockJournal, AppendWriteEvent) {
   expect_append_journaler(mock_journaler);
   expect_wait_future(mock_future, &on_journal_safe);
   ASSERT_EQ(1U, when_append_write_event(mock_image_ctx, mock_journal, 1 << 17));
-  mock_journal.get_work_queue()->drain();
+  mock_journal->get_work_queue()->drain();
 
   on_journal_safe->complete(0);
   C_SaferCond event_ctx;
-  mock_journal.wait_event(1U, &event_ctx);
+  mock_journal->wait_event(1U, &event_ctx);
   ASSERT_EQ(0, event_ctx.wait());
 
   expect_future_committed(mock_journaler);
   expect_future_committed(mock_journaler);
   expect_future_committed(mock_journaler);
-  mock_journal.commit_io_event(1U, 0);
+  mock_journal->commit_io_event(1U, 0);
   ictx->op_work_queue->drain();
 
   expect_shut_down_journaler(mock_journaler);
@@ -1097,7 +1131,7 @@ TEST_F(TestMockJournal, EventCommitError) {
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   MockJournalImageCtx mock_image_ctx(*ictx);
-  MockJournal mock_journal(mock_image_ctx);
+  MockJournal *mock_journal = new MockJournal(mock_image_ctx);
   MockObjectDispatch mock_object_dispatch;
   ::journal::MockJournaler mock_journaler;
   MockJournalOpenRequest mock_open_request;
@@ -1105,6 +1139,7 @@ TEST_F(TestMockJournal, EventCommitError) {
                mock_journaler, mock_open_request);
   BOOST_SCOPE_EXIT_ALL(&) {
     close_journal(mock_image_ctx, mock_journal, mock_journaler);
+    mock_journal->put();
   };
 
   ::journal::MockFuture mock_future;
@@ -1112,19 +1147,19 @@ TEST_F(TestMockJournal, EventCommitError) {
   expect_append_journaler(mock_journaler);
   expect_wait_future(mock_future, &on_journal_safe);
   ASSERT_EQ(1U, when_append_io_event(mock_image_ctx, mock_journal, 0));
-  mock_journal.get_work_queue()->drain();
+  mock_journal->get_work_queue()->drain();
 
   // commit the event in the journal w/o waiting writeback
   expect_future_committed(mock_journaler);
   C_SaferCond object_request_ctx;
-  mock_journal.wait_event(1U, &object_request_ctx);
+  mock_journal->wait_event(1U, &object_request_ctx);
   on_journal_safe->complete(-EINVAL);
   ASSERT_EQ(-EINVAL, object_request_ctx.wait());
 
   // cache should receive the error after attempting writeback
   expect_future_is_valid(mock_future);
   C_SaferCond flush_ctx;
-  mock_journal.flush_event(1U, &flush_ctx);
+  mock_journal->flush_event(1U, &flush_ctx);
   ASSERT_EQ(-EINVAL, flush_ctx.wait());
 
   expect_shut_down_journaler(mock_journaler);
@@ -1137,7 +1172,7 @@ TEST_F(TestMockJournal, EventCommitErrorWithPendingWriteback) {
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   MockJournalImageCtx mock_image_ctx(*ictx);
-  MockJournal mock_journal(mock_image_ctx);
+  MockJournal *mock_journal = new MockJournal(mock_image_ctx);
   MockObjectDispatch mock_object_dispatch;
   ::journal::MockJournaler mock_journaler;
   MockJournalOpenRequest mock_open_request;
@@ -1145,6 +1180,7 @@ TEST_F(TestMockJournal, EventCommitErrorWithPendingWriteback) {
                mock_journaler, mock_open_request);
   BOOST_SCOPE_EXIT_ALL(&) {
     close_journal(mock_image_ctx, mock_journal, mock_journaler);
+    mock_journal->put();
   };
 
   ::journal::MockFuture mock_future;
@@ -1152,16 +1188,16 @@ TEST_F(TestMockJournal, EventCommitErrorWithPendingWriteback) {
   expect_append_journaler(mock_journaler);
   expect_wait_future(mock_future, &on_journal_safe);
   ASSERT_EQ(1U, when_append_io_event(mock_image_ctx, mock_journal, 0));
-  mock_journal.get_work_queue()->drain();
+  mock_journal->get_work_queue()->drain();
 
   expect_future_is_valid(mock_future);
   C_SaferCond flush_ctx;
-  mock_journal.flush_event(1U, &flush_ctx);
+  mock_journal->flush_event(1U, &flush_ctx);
 
   // commit the event in the journal w/ waiting cache writeback
   expect_future_committed(mock_journaler);
   C_SaferCond object_request_ctx;
-  mock_journal.wait_event(1U, &object_request_ctx);
+  mock_journal->wait_event(1U, &object_request_ctx);
   on_journal_safe->complete(-EINVAL);
   ASSERT_EQ(-EINVAL, object_request_ctx.wait());
 
@@ -1178,7 +1214,7 @@ TEST_F(TestMockJournal, IOCommitError) {
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   MockJournalImageCtx mock_image_ctx(*ictx);
-  MockJournal mock_journal(mock_image_ctx);
+  MockJournal *mock_journal = new MockJournal(mock_image_ctx);
   MockObjectDispatch mock_object_dispatch;
   ::journal::MockJournaler mock_journaler;
   MockJournalOpenRequest mock_open_request;
@@ -1186,6 +1222,7 @@ TEST_F(TestMockJournal, IOCommitError) {
                mock_journaler, mock_open_request);
   BOOST_SCOPE_EXIT_ALL(&) {
     close_journal(mock_image_ctx, mock_journal, mock_journaler);
+    mock_journal->put();
   };
 
   ::journal::MockFuture mock_future;
@@ -1193,12 +1230,12 @@ TEST_F(TestMockJournal, IOCommitError) {
   expect_append_journaler(mock_journaler);
   expect_wait_future(mock_future, &on_journal_safe);
   ASSERT_EQ(1U, when_append_io_event(mock_image_ctx, mock_journal, 0));
-  mock_journal.get_work_queue()->drain();
+  mock_journal->get_work_queue()->drain();
 
   // failed IO remains uncommitted in journal
   on_journal_safe->complete(0);
   ictx->op_work_queue->drain();
-  mock_journal.commit_io_event(1U, -EINVAL);
+  mock_journal->commit_io_event(1U, -EINVAL);
 
   expect_shut_down_journaler(mock_journaler);
 }
@@ -1210,7 +1247,7 @@ TEST_F(TestMockJournal, IOCommitErrorFiltered) {
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   MockJournalImageCtx mock_image_ctx(*ictx);
-  MockJournal mock_journal(mock_image_ctx);
+  MockJournal *mock_journal = new MockJournal(mock_image_ctx);
   MockObjectDispatch mock_object_dispatch;
   ::journal::MockJournaler mock_journaler;
   MockJournalOpenRequest mock_open_request;
@@ -1218,6 +1255,7 @@ TEST_F(TestMockJournal, IOCommitErrorFiltered) {
                mock_journaler, mock_open_request);
   BOOST_SCOPE_EXIT_ALL(&) {
     close_journal(mock_image_ctx, mock_journal, mock_journaler);
+    mock_journal->put();
   };
 
   ::journal::MockFuture mock_future;
@@ -1225,13 +1263,13 @@ TEST_F(TestMockJournal, IOCommitErrorFiltered) {
   expect_append_journaler(mock_journaler);
   expect_wait_future(mock_future, &on_journal_safe);
   ASSERT_EQ(1U, when_append_io_event(mock_image_ctx, mock_journal, -EILSEQ));
-  mock_journal.get_work_queue()->drain();
+  mock_journal->get_work_queue()->drain();
 
   // filter failed IO committed in journal
   on_journal_safe->complete(0);
   ictx->op_work_queue->drain();
   expect_future_committed(mock_journaler);
-  mock_journal.commit_io_event(1U, -EILSEQ);
+  mock_journal->commit_io_event(1U, -EILSEQ);
 
   expect_shut_down_journaler(mock_journaler);
 }
@@ -1243,7 +1281,7 @@ TEST_F(TestMockJournal, FlushCommitPosition) {
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   MockJournalImageCtx mock_image_ctx(*ictx);
-  MockJournal mock_journal(mock_image_ctx);
+  MockJournal *mock_journal = new MockJournal(mock_image_ctx);
   MockObjectDispatch mock_object_dispatch;
   ::journal::MockJournaler mock_journaler;
   MockJournalOpenRequest mock_open_request;
@@ -1251,11 +1289,12 @@ TEST_F(TestMockJournal, FlushCommitPosition) {
                mock_journaler, mock_open_request);
   BOOST_SCOPE_EXIT_ALL(&) {
     close_journal(mock_image_ctx, mock_journal, mock_journaler);
+    mock_journal->put();
   };
 
   expect_flush_commit_position(mock_journaler);
   C_SaferCond ctx;
-  mock_journal.flush_commit_position(&ctx);
+  mock_journal->flush_commit_position(&ctx);
   ASSERT_EQ(0, ctx.wait());
 
   expect_shut_down_journaler(mock_journaler);
@@ -1268,7 +1307,7 @@ TEST_F(TestMockJournal, ExternalReplay) {
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   MockJournalImageCtx mock_image_ctx(*ictx);
-  MockJournal mock_journal(mock_image_ctx);
+  MockJournal *mock_journal = new MockJournal(mock_image_ctx);
   MockObjectDispatch mock_object_dispatch;
   ::journal::MockJournaler mock_journaler;
   MockJournalOpenRequest mock_open_request;
@@ -1276,6 +1315,7 @@ TEST_F(TestMockJournal, ExternalReplay) {
                mock_journaler, mock_open_request);
   BOOST_SCOPE_EXIT_ALL(&) {
     close_journal(mock_image_ctx, mock_journal, mock_journaler);
+    mock_journal->put();
   };
 
   InSequence seq;
@@ -1287,10 +1327,10 @@ TEST_F(TestMockJournal, ExternalReplay) {
   C_SaferCond start_ctx;
 
   journal::Replay<MockJournalImageCtx> *journal_replay = nullptr;
-  mock_journal.start_external_replay(&journal_replay, &start_ctx);
+  mock_journal->start_external_replay(&journal_replay, &start_ctx);
   ASSERT_EQ(0, start_ctx.wait());
 
-  mock_journal.stop_external_replay();
+  mock_journal->stop_external_replay();
 }
 
 TEST_F(TestMockJournal, ExternalReplayFailure) {
@@ -1300,7 +1340,7 @@ TEST_F(TestMockJournal, ExternalReplayFailure) {
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   MockJournalImageCtx mock_image_ctx(*ictx);
-  MockJournal mock_journal(mock_image_ctx);
+  MockJournal *mock_journal = new MockJournal(mock_image_ctx);
   MockObjectDispatch mock_object_dispatch;
   ::journal::MockJournaler mock_journaler;
   MockJournalOpenRequest mock_open_request;
@@ -1308,6 +1348,7 @@ TEST_F(TestMockJournal, ExternalReplayFailure) {
                mock_journaler, mock_open_request);
   BOOST_SCOPE_EXIT_ALL(&) {
     close_journal(mock_image_ctx, mock_journal, mock_journaler);
+    mock_journal->put();
   };
 
   InSequence seq;
@@ -1319,7 +1360,7 @@ TEST_F(TestMockJournal, ExternalReplayFailure) {
   C_SaferCond start_ctx;
 
   journal::Replay<MockJournalImageCtx> *journal_replay = nullptr;
-  mock_journal.start_external_replay(&journal_replay, &start_ctx);
+  mock_journal->start_external_replay(&journal_replay, &start_ctx);
   ASSERT_EQ(-EINVAL, start_ctx.wait());
 }
 
@@ -1330,7 +1371,7 @@ TEST_F(TestMockJournal, AppendDisabled) {
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   MockJournalImageCtx mock_image_ctx(*ictx);
-  MockJournal mock_journal(mock_image_ctx);
+  MockJournal *mock_journal = new MockJournal(mock_image_ctx);
   MockObjectDispatch mock_object_dispatch;
   MockJournalPolicy mock_journal_policy;
 
@@ -1340,18 +1381,19 @@ TEST_F(TestMockJournal, AppendDisabled) {
                mock_journaler, mock_open_request);
   BOOST_SCOPE_EXIT_ALL(&) {
     close_journal(mock_image_ctx, mock_journal, mock_journaler);
+    mock_journal->put();
   };
 
   InSequence seq;
   std::shared_lock image_locker{mock_image_ctx.image_lock};
   EXPECT_CALL(mock_image_ctx, get_journal_policy()).WillOnce(
     Return(ictx->get_journal_policy()));
-  ASSERT_TRUE(mock_journal.is_journal_appending());
+  ASSERT_TRUE(mock_journal->is_journal_appending());
 
   EXPECT_CALL(mock_image_ctx, get_journal_policy()).WillOnce(
     Return(&mock_journal_policy));
   EXPECT_CALL(mock_journal_policy, append_disabled()).WillOnce(Return(true));
-  ASSERT_FALSE(mock_journal.is_journal_appending());
+  ASSERT_FALSE(mock_journal->is_journal_appending());
 
   expect_shut_down_journaler(mock_journaler);
 }
@@ -1363,7 +1405,12 @@ TEST_F(TestMockJournal, CloseListenerEvent) {
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   MockJournalImageCtx mock_image_ctx(*ictx);
-  MockJournal mock_journal(mock_image_ctx);
+  MockJournal *mock_journal = new MockJournal(mock_image_ctx);
+
+  BOOST_SCOPE_EXIT(&mock_journal) {
+    mock_journal->put();
+  } BOOST_SCOPE_EXIT_END
+
   MockObjectDispatch mock_object_dispatch;
   ::journal::MockJournaler mock_journaler;
   MockJournalOpenRequest mock_open_request;
@@ -1382,13 +1429,13 @@ TEST_F(TestMockJournal, CloseListenerEvent) {
       ADD_FAILURE() << "unexpected promotion event";
     }
   } listener;
-  mock_journal.add_listener(&listener);
+  mock_journal->add_listener(&listener);
 
   expect_shut_down_journaler(mock_journaler);
   close_journal(mock_image_ctx, mock_journal, mock_journaler);
 
   ASSERT_EQ(0, listener.ctx.wait());
-  mock_journal.remove_listener(&listener);
+  mock_journal->remove_listener(&listener);
 }
 
 TEST_F(TestMockJournal, ResyncRequested) {
@@ -1398,7 +1445,7 @@ TEST_F(TestMockJournal, ResyncRequested) {
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   MockJournalImageCtx mock_image_ctx(*ictx);
-  MockJournal mock_journal(mock_image_ctx);
+  MockJournal *mock_journal = new MockJournal(mock_image_ctx);
   MockObjectDispatch mock_object_dispatch;
   ::journal::MockJournaler mock_journaler;
   MockJournalOpenRequest mock_open_request;
@@ -1418,11 +1465,12 @@ TEST_F(TestMockJournal, ResyncRequested) {
       ADD_FAILURE() << "unexpected promotion event";
     }
   } listener;
-  mock_journal.add_listener(&listener);
+  mock_journal->add_listener(&listener);
 
   BOOST_SCOPE_EXIT_ALL(&) {
-    mock_journal.remove_listener(&listener);
+    mock_journal->remove_listener(&listener);
     close_journal(mock_image_ctx, mock_journal, mock_journaler);
+    mock_journal->put();
   };
 
   InSequence seq;
@@ -1452,7 +1500,7 @@ TEST_F(TestMockJournal, ForcePromoted) {
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   MockJournalImageCtx mock_image_ctx(*ictx);
-  MockJournal mock_journal(mock_image_ctx);
+  MockJournal *mock_journal = new MockJournal(mock_image_ctx);
   MockObjectDispatch mock_object_dispatch;
   ::journal::MockJournaler mock_journaler;
   MockJournalOpenRequest mock_open_request;
@@ -1471,11 +1519,12 @@ TEST_F(TestMockJournal, ForcePromoted) {
       ctx.complete(0);
     }
   } listener;
-  mock_journal.add_listener(&listener);
+  mock_journal->add_listener(&listener);
 
   BOOST_SCOPE_EXIT_ALL(&) {
-    mock_journal.remove_listener(&listener);
+    mock_journal->remove_listener(&listener);
     close_journal(mock_image_ctx, mock_journal, mock_journaler);
+    mock_journal->put();
   };
 
   InSequence seq;
@@ -1504,7 +1553,7 @@ TEST_F(TestMockJournal, UserFlushed) {
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   MockJournalImageCtx mock_image_ctx(*ictx);
-  MockJournal mock_journal(mock_image_ctx);
+  MockJournal *mock_journal = new MockJournal(mock_image_ctx);
   MockObjectDispatch mock_object_dispatch;
   ::journal::MockJournaler mock_journaler;
   MockJournalOpenRequest mock_open_request;
@@ -1512,10 +1561,11 @@ TEST_F(TestMockJournal, UserFlushed) {
                mock_journaler, mock_open_request);
   BOOST_SCOPE_EXIT_ALL(&) {
     close_journal(mock_image_ctx, mock_journal, mock_journaler);
+    mock_journal->put();
   };
 
   expect_set_append_batch_options(mock_image_ctx, mock_journaler, true);
-  mock_journal.user_flushed();
+  mock_journal->user_flushed();
 
   expect_shut_down_journaler(mock_journaler);
 }

diff --git a/src/test/librbd/test_mock_ObjectMap.cc b/src/test/librbd/test_mock_ObjectMap.cc
index a96a1588a7989566416f30f181691af06b1fc864..39e29172c5854515cdedf12e472725b0b73757e1 100644 (file)
--- a/src/test/librbd/test_mock_ObjectMap.cc
+++ b/src/test/librbd/test_mock_ObjectMap.cc
@@ -8,6 +8,7 @@
 #include "librbd/object_map/RefreshRequest.h"
 #include "librbd/object_map/UnlockRequest.h"
 #include "librbd/object_map/UpdateRequest.h"
+#include <boost/scope_exit.hpp>
 
 namespace librbd {
 
@@ -172,17 +173,21 @@ TEST_F(TestMockObjectMap, NonDetainedUpdate) {
   MockUnlockRequest mock_unlock_request;
   expect_unlock(mock_image_ctx, mock_unlock_request, 0);
 
-  MockObjectMap mock_object_map(mock_image_ctx, CEPH_NOSNAP);
+  MockObjectMap *mock_object_map = new MockObjectMap(mock_image_ctx, CEPH_NOSNAP);
+  BOOST_SCOPE_EXIT(&mock_object_map) {
+    mock_object_map->put();
+  } BOOST_SCOPE_EXIT_END
+
   C_SaferCond open_ctx;
-  mock_object_map.open(&open_ctx);
+  mock_object_map->open(&open_ctx);
   ASSERT_EQ(0, open_ctx.wait());
 
   C_SaferCond update_ctx1;
   C_SaferCond update_ctx2;
   {
     std::shared_lock image_locker{mock_image_ctx.image_lock};
-    mock_object_map.aio_update(CEPH_NOSNAP, 0, 1, {}, {}, false, &update_ctx1);
-    mock_object_map.aio_update(CEPH_NOSNAP, 1, 1, {}, {}, false, &update_ctx2);
+    mock_object_map->aio_update(CEPH_NOSNAP, 0, 1, {}, {}, false, &update_ctx1);
+    mock_object_map->aio_update(CEPH_NOSNAP, 1, 1, {}, {}, false, &update_ctx2);
   }
 
   finish_update_2->complete(0);
@@ -192,7 +197,7 @@ TEST_F(TestMockObjectMap, NonDetainedUpdate) {
   ASSERT_EQ(0, update_ctx1.wait());
 
   C_SaferCond close_ctx;
-  mock_object_map.close(&close_ctx);
+  mock_object_map->close(&close_ctx);
   ASSERT_EQ(0, close_ctx.wait());
 }
 
@@ -227,9 +232,13 @@ TEST_F(TestMockObjectMap, DetainedUpdate) {
   MockUnlockRequest mock_unlock_request;
   expect_unlock(mock_image_ctx, mock_unlock_request, 0);
 
-  MockObjectMap mock_object_map(mock_image_ctx, CEPH_NOSNAP);
+  MockObjectMap *mock_object_map = new MockObjectMap(mock_image_ctx, CEPH_NOSNAP);
+  BOOST_SCOPE_EXIT(&mock_object_map) {
+    mock_object_map->put();
+  } BOOST_SCOPE_EXIT_END
+
   C_SaferCond open_ctx;
-  mock_object_map.open(&open_ctx);
+  mock_object_map->open(&open_ctx);
   ASSERT_EQ(0, open_ctx.wait());
 
   C_SaferCond update_ctx1;
@@ -238,13 +247,13 @@ TEST_F(TestMockObjectMap, DetainedUpdate) {
   C_SaferCond update_ctx4;
   {
     std::shared_lock image_locker{mock_image_ctx.image_lock};
-    mock_object_map.aio_update(CEPH_NOSNAP, 1, 4, 1, {}, {}, false,
+    mock_object_map->aio_update(CEPH_NOSNAP, 1, 4, 1, {}, {}, false,
                                &update_ctx1);
-    mock_object_map.aio_update(CEPH_NOSNAP, 1, 3, 1, {}, {}, false,
+    mock_object_map->aio_update(CEPH_NOSNAP, 1, 3, 1, {}, {}, false,
                                &update_ctx2);
-    mock_object_map.aio_update(CEPH_NOSNAP, 2, 3, 1, {}, {}, false,
+    mock_object_map->aio_update(CEPH_NOSNAP, 2, 3, 1, {}, {}, false,
                                &update_ctx3);
-    mock_object_map.aio_update(CEPH_NOSNAP, 0, 2, 1, {}, {}, false,
+    mock_object_map->aio_update(CEPH_NOSNAP, 0, 2, 1, {}, {}, false,
                                &update_ctx4);
   }
 
@@ -268,7 +277,7 @@ TEST_F(TestMockObjectMap, DetainedUpdate) {
   ASSERT_EQ(0, update_ctx4.wait());
 
   C_SaferCond close_ctx;
-  mock_object_map.close(&close_ctx);
+  mock_object_map->close(&close_ctx);
   ASSERT_EQ(0, close_ctx.wait());
 }