From: Venky Shankar Date: Mon, 12 Feb 2018 03:29:12 +0000 (-0500) Subject: test: fixup rbd tests as a side effect of reference counting X-Git-Tag: v15.1.0~867^2 X-Git-Url: http://git-server-git.apps.pok.os.sepia.ceph.com/?a=commitdiff_plain;h=f6b4d3d0f318a21f3e0975b8d061502cfd2fda67;p=ceph.git 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 Signed-off-by: Venky Shankar --- diff --git a/src/test/librbd/exclusive_lock/test_mock_PostAcquireRequest.cc b/src/test/librbd/exclusive_lock/test_mock_PostAcquireRequest.cc index cd84c21fba4..b18269236a7 100644 --- 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 989e793fc73..38110a33d0a 100644 --- 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 65a20db9dbe..a438be8f187 100644 --- 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 0f89928818c..babbfe425be 100644 --- 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 019eb4d5424..76e0cdab7c6 100644 --- 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 efb4fa4e33e..2bf552f3b68 100644 --- 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 31806217af1..15baf790367 100644 --- 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 2692a30ff0b..d72408403e8 100644 --- 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 bool aio_update(uint64_t snap_id, uint64_t start_object_no, uint8_t new_state, const boost::optional ¤t_state, diff --git a/src/test/librbd/object_map/test_mock_SnapshotRemoveRequest.cc b/src/test/librbd/object_map/test_mock_SnapshotRemoveRequest.cc index a4d79240aa0..f02d3d3e70d 100644 --- 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 a880a54afdc..b437f55b736 100644 --- 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 96552c4cdb6..fa14ddb37fe 100644 --- 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 8e80beeacb5..61497b2af85 100644 --- 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 7e9bd9eb939..2ea2d1701fe 100644 --- 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 d888fbf3cf2..d198620ba72 100644 --- 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 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 eacde946a0b..ae523acc255 100644 --- 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 +#include namespace librbd { @@ -164,57 +165,57 @@ public: typedef exclusive_lock::PostAcquireRequest MockPostAcquireRequest; typedef exclusive_lock::PreReleaseRequest 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(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 dcc74fcc889..78a7ae73ccc 100644 --- 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(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 *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 *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 a96a1588a79..39e29172c58 100644 --- 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 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()); }