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.apps.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 cd84c21fba47c..b18269236a7c4 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 989e793fc7344..38110a33d0acd 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 65a20db9dbee0..a438be8f187f8 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 0f89928818c21..babbfe425be81 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 019eb4d5424b7..76e0cdab7c6c6 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 efb4fa4e33ed3..2bf552f3b6899 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 31806217af165..15baf790367c7 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 2692a30ff0b85..d72408403e8e9 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 a4d79240aa05f..f02d3d3e70da8 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 a880a54afdc8f..b437f55b7361d 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 96552c4cdb696..fa14ddb37fed2 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 8e80beeacb51a..61497b2af8571 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 7e9bd9eb939ae..2ea2d1701fedf 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 d888fbf3cf291..d198620ba7208 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 eacde946a0ba5..ae523acc25579 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 dcc74fcc889bc..78a7ae73ccca0 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 a96a1588a7989..39e29172c5854 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()); }