From: Jason Dillaman Date: Fri, 11 Mar 2016 01:26:53 +0000 (-0500) Subject: librbd: prefix local maintenance ops methods X-Git-Tag: v10.1.0~104^2~12 X-Git-Url: http://git-server-git.apps.pok.os.sepia.ceph.com/?a=commitdiff_plain;h=14a264d4e2b2d0ac1ecccb2de764753f390480c5;p=ceph.git librbd: prefix local maintenance ops methods This will help to differentiate between the methods that send an RPC request if the lock isn't owned vs execute locally if it is owned. Signed-off-by: Jason Dillaman --- diff --git a/src/librbd/ImageWatcher.cc b/src/librbd/ImageWatcher.cc index b6542807898..25deb8b67e7 100644 --- a/src/librbd/ImageWatcher.cc +++ b/src/librbd/ImageWatcher.cc @@ -656,7 +656,7 @@ bool ImageWatcher::handle_payload(const FlattenPayload &payload, if (new_request) { ldout(m_image_ctx.cct, 10) << this << " remote flatten request: " << payload.async_request_id << dendl; - m_image_ctx.operations->flatten(*prog_ctx, ctx); + m_image_ctx.operations->execute_flatten(*prog_ctx, ctx); } ::encode(ResponseMessage(r), ack_ctx->out); @@ -678,7 +678,7 @@ bool ImageWatcher::handle_payload(const ResizePayload &payload, ldout(m_image_ctx.cct, 10) << this << " remote resize request: " << payload.async_request_id << " " << payload.size << dendl; - m_image_ctx.operations->resize(payload.size, *prog_ctx, ctx, 0); + m_image_ctx.operations->execute_resize(payload.size, *prog_ctx, ctx, 0); } ::encode(ResponseMessage(r), ack_ctx->out); @@ -694,8 +694,9 @@ bool ImageWatcher::handle_payload(const SnapCreatePayload &payload, ldout(m_image_ctx.cct, 10) << this << " remote snap_create request: " << payload.snap_name << dendl; - m_image_ctx.operations->snap_create(payload.snap_name.c_str(), - new C_ResponseMessage(ack_ctx), 0); + m_image_ctx.operations->execute_snap_create(payload.snap_name.c_str(), + new C_ResponseMessage(ack_ctx), + 0); return false; } return true; @@ -710,9 +711,9 @@ bool ImageWatcher::handle_payload(const SnapRenamePayload &payload, << payload.snap_id << " to " << payload.snap_name << dendl; - m_image_ctx.operations->snap_rename(payload.snap_id, - payload.snap_name.c_str(), - new C_ResponseMessage(ack_ctx)); + m_image_ctx.operations->execute_snap_rename(payload.snap_id, + payload.snap_name.c_str(), + new C_ResponseMessage(ack_ctx)); return false; } return true; @@ -726,8 +727,8 @@ bool ImageWatcher::handle_payload(const SnapRemovePayload &payload, ldout(m_image_ctx.cct, 10) << this << " remote snap_remove request: " << payload.snap_name << dendl; - m_image_ctx.operations->snap_remove(payload.snap_name.c_str(), - new C_ResponseMessage(ack_ctx)); + m_image_ctx.operations->execute_snap_remove(payload.snap_name.c_str(), + new C_ResponseMessage(ack_ctx)); return false; } return true; @@ -741,8 +742,8 @@ bool ImageWatcher::handle_payload(const SnapProtectPayload& payload, ldout(m_image_ctx.cct, 10) << this << " remote snap_protect request: " << payload.snap_name << dendl; - m_image_ctx.operations->snap_protect(payload.snap_name.c_str(), - new C_ResponseMessage(ack_ctx)); + m_image_ctx.operations->execute_snap_protect(payload.snap_name.c_str(), + new C_ResponseMessage(ack_ctx)); return false; } return true; @@ -756,8 +757,8 @@ bool ImageWatcher::handle_payload(const SnapUnprotectPayload& payload, ldout(m_image_ctx.cct, 10) << this << " remote snap_unprotect request: " << payload.snap_name << dendl; - m_image_ctx.operations->snap_unprotect(payload.snap_name.c_str(), - new C_ResponseMessage(ack_ctx)); + m_image_ctx.operations->execute_snap_unprotect(payload.snap_name.c_str(), + new C_ResponseMessage(ack_ctx)); return false; } return true; @@ -777,7 +778,7 @@ bool ImageWatcher::handle_payload(const RebuildObjectMapPayload& payload, ldout(m_image_ctx.cct, 10) << this << " remote rebuild object map request: " << payload.async_request_id << dendl; - m_image_ctx.operations->rebuild_object_map(*prog_ctx, ctx); + m_image_ctx.operations->execute_rebuild_object_map(*prog_ctx, ctx); } ::encode(ResponseMessage(r), ack_ctx->out); @@ -793,7 +794,7 @@ bool ImageWatcher::handle_payload(const RenamePayload& payload, ldout(m_image_ctx.cct, 10) << this << " remote rename request: " << payload.image_name << dendl; - m_image_ctx.operations->rename(payload.image_name.c_str(), + m_image_ctx.operations->execute_rename(payload.image_name.c_str(), new C_ResponseMessage(ack_ctx)); return false; } diff --git a/src/librbd/Operations.cc b/src/librbd/Operations.cc index e990304cc90..ef33e436fc8 100644 --- a/src/librbd/Operations.cc +++ b/src/librbd/Operations.cc @@ -235,7 +235,7 @@ int Operations::flatten(ProgressContext &prog_ctx) { uint64_t request_id = ++m_async_request_seq; r = invoke_async_request("flatten", false, - boost::bind(&Operations::flatten, this, + boost::bind(&Operations::execute_flatten, this, boost::ref(prog_ctx), _1), boost::bind(&ImageWatcher::notify_flatten, m_image_ctx.image_watcher, request_id, @@ -249,7 +249,8 @@ int Operations::flatten(ProgressContext &prog_ctx) { } template -void Operations::flatten(ProgressContext &prog_ctx, Context *on_finish) { +void Operations::execute_flatten(ProgressContext &prog_ctx, + Context *on_finish) { assert(m_image_ctx.owner_lock.is_locked()); assert(m_image_ctx.exclusive_lock == nullptr || m_image_ctx.exclusive_lock->is_lock_owner()); @@ -311,8 +312,8 @@ int Operations::rebuild_object_map(ProgressContext &prog_ctx) { uint64_t request_id = ++m_async_request_seq; r = invoke_async_request("rebuild object map", true, - boost::bind(&Operations::rebuild_object_map, this, - boost::ref(prog_ctx), _1), + boost::bind(&Operations::execute_rebuild_object_map, + this, boost::ref(prog_ctx), _1), boost::bind(&ImageWatcher::notify_rebuild_object_map, m_image_ctx.image_watcher, request_id, boost::ref(prog_ctx), _1)); @@ -325,8 +326,8 @@ int Operations::rebuild_object_map(ProgressContext &prog_ctx) { } template -void Operations::rebuild_object_map(ProgressContext &prog_ctx, - Context *on_finish) { +void Operations::execute_rebuild_object_map(ProgressContext &prog_ctx, + Context *on_finish) { assert(m_image_ctx.owner_lock.is_locked()); assert(m_image_ctx.exclusive_lock == nullptr || m_image_ctx.exclusive_lock->is_lock_owner()); @@ -368,7 +369,7 @@ int Operations::rename(const char *dstname) { if (m_image_ctx.test_features(RBD_FEATURE_JOURNALING)) { r = invoke_async_request("rename", true, - boost::bind(&Operations::rename, this, + boost::bind(&Operations::execute_rename, this, dstname, _1), boost::bind(&ImageWatcher::notify_rename, m_image_ctx.image_watcher, dstname, @@ -379,7 +380,7 @@ int Operations::rename(const char *dstname) { } else { RWLock::RLocker owner_lock(m_image_ctx.owner_lock); C_SaferCond cond_ctx; - rename(dstname, &cond_ctx); + execute_rename(dstname, &cond_ctx); r = cond_ctx.wait(); if (r < 0) { @@ -392,7 +393,7 @@ int Operations::rename(const char *dstname) { } template -void Operations::rename(const char *dstname, Context *on_finish) { +void Operations::execute_rename(const char *dstname, Context *on_finish) { assert(m_image_ctx.owner_lock.is_locked()); if (m_image_ctx.test_features(RBD_FEATURE_JOURNALING)) { assert(m_image_ctx.exclusive_lock == nullptr || @@ -428,7 +429,7 @@ int Operations::resize(uint64_t size, ProgressContext& prog_ctx) { uint64_t request_id = ++m_async_request_seq; r = invoke_async_request("resize", false, - boost::bind(&Operations::resize, this, + boost::bind(&Operations::execute_resize, this, size, boost::ref(prog_ctx), _1, 0), boost::bind(&ImageWatcher::notify_resize, m_image_ctx.image_watcher, request_id, @@ -440,8 +441,9 @@ int Operations::resize(uint64_t size, ProgressContext& prog_ctx) { } template -void Operations::resize(uint64_t size, ProgressContext &prog_ctx, - Context *on_finish, uint64_t journal_op_tid) { +void Operations::execute_resize(uint64_t size, ProgressContext &prog_ctx, + Context *on_finish, + uint64_t journal_op_tid) { assert(m_image_ctx.owner_lock.is_locked()); assert(m_image_ctx.exclusive_lock == nullptr || m_image_ctx.exclusive_lock->is_lock_owner()); @@ -489,8 +491,8 @@ int Operations::snap_create(const char *snap_name) { } r = invoke_async_request("snap_create", true, - boost::bind(&Operations::snap_create, this, - snap_name, _1, 0), + boost::bind(&Operations::execute_snap_create, + this, snap_name, _1, 0), boost::bind(&ImageWatcher::notify_snap_create, m_image_ctx.image_watcher, snap_name, _1)); @@ -503,8 +505,9 @@ int Operations::snap_create(const char *snap_name) { } template -void Operations::snap_create(const char *snap_name, Context *on_finish, - uint64_t journal_op_tid) { +void Operations::execute_snap_create(const char *snap_name, + Context *on_finish, + uint64_t journal_op_tid) { assert(m_image_ctx.owner_lock.is_locked()); assert(m_image_ctx.exclusive_lock == nullptr || m_image_ctx.exclusive_lock->is_lock_owner()); @@ -560,7 +563,7 @@ int Operations::snap_rollback(const char *snap_name, } C_SaferCond cond_ctx; - snap_rollback(snap_name, prog_ctx, &cond_ctx); + execute_snap_rollback(snap_name, prog_ctx, &cond_ctx); r = cond_ctx.wait(); if (r < 0) { return r; @@ -571,9 +574,9 @@ int Operations::snap_rollback(const char *snap_name, } template -void Operations::snap_rollback(const char *snap_name, - ProgressContext& prog_ctx, - Context *on_finish) { +void Operations::execute_snap_rollback(const char *snap_name, + ProgressContext& prog_ctx, + Context *on_finish) { assert(m_image_ctx.owner_lock.is_locked()); CephContext *cct = m_image_ctx.cct; ldout(cct, 5) << this << " " << __func__ << ": snap_name=" << snap_name @@ -626,8 +629,8 @@ int Operations::snap_remove(const char *snap_name) { if (proxy_op) { r = invoke_async_request("snap_remove", true, - boost::bind(&Operations::snap_remove, this, - snap_name, _1), + boost::bind(&Operations::execute_snap_remove, + this, snap_name, _1), boost::bind(&ImageWatcher::notify_snap_remove, m_image_ctx.image_watcher, snap_name, _1)); @@ -637,7 +640,7 @@ int Operations::snap_remove(const char *snap_name) { } else { RWLock::RLocker owner_lock(m_image_ctx.owner_lock); C_SaferCond cond_ctx; - snap_remove(snap_name, &cond_ctx); + execute_snap_remove(snap_name, &cond_ctx); r = cond_ctx.wait(); if (r < 0) { @@ -650,7 +653,8 @@ int Operations::snap_remove(const char *snap_name) { } template -void Operations::snap_remove(const char *snap_name, Context *on_finish) { +void Operations::execute_snap_remove(const char *snap_name, + Context *on_finish) { assert(m_image_ctx.owner_lock.is_locked()); { if ((m_image_ctx.features & RBD_FEATURE_FAST_DIFF) != 0) { @@ -721,8 +725,8 @@ int Operations::snap_rename(const char *srcname, const char *dstname) { if (m_image_ctx.test_features(RBD_FEATURE_JOURNALING)) { r = invoke_async_request("snap_rename", true, - boost::bind(&Operations::snap_rename, this, - snap_id, dstname, _1), + boost::bind(&Operations::execute_snap_rename, + this, snap_id, dstname, _1), boost::bind(&ImageWatcher::notify_snap_rename, m_image_ctx.image_watcher, snap_id, dstname, _1)); @@ -732,7 +736,7 @@ int Operations::snap_rename(const char *srcname, const char *dstname) { } else { RWLock::RLocker owner_lock(m_image_ctx.owner_lock); C_SaferCond cond_ctx; - snap_rename(snap_id, dstname, &cond_ctx); + execute_snap_rename(snap_id, dstname, &cond_ctx); r = cond_ctx.wait(); if (r < 0) { @@ -745,8 +749,9 @@ int Operations::snap_rename(const char *srcname, const char *dstname) { } template -void Operations::snap_rename(const uint64_t src_snap_id, - const char *dst_name, Context *on_finish) { +void Operations::execute_snap_rename(const uint64_t src_snap_id, + const char *dst_name, + Context *on_finish) { assert(m_image_ctx.owner_lock.is_locked()); if ((m_image_ctx.features & RBD_FEATURE_JOURNALING) != 0) { assert(m_image_ctx.exclusive_lock == nullptr || @@ -796,8 +801,8 @@ int Operations::snap_protect(const char *snap_name) { if (m_image_ctx.test_features(RBD_FEATURE_JOURNALING)) { r = invoke_async_request("snap_protect", true, - boost::bind(&Operations::snap_protect, this, - snap_name, _1), + boost::bind(&Operations::execute_snap_protect, + this, snap_name, _1), boost::bind(&ImageWatcher::notify_snap_protect, m_image_ctx.image_watcher, snap_name, _1)); @@ -807,7 +812,7 @@ int Operations::snap_protect(const char *snap_name) { } else { RWLock::RLocker owner_lock(m_image_ctx.owner_lock); C_SaferCond cond_ctx; - snap_protect(snap_name, &cond_ctx); + execute_snap_protect(snap_name, &cond_ctx); r = cond_ctx.wait(); if (r < 0) { @@ -818,7 +823,8 @@ int Operations::snap_protect(const char *snap_name) { } template -void Operations::snap_protect(const char *snap_name, Context *on_finish) { +void Operations::execute_snap_protect(const char *snap_name, + Context *on_finish) { assert(m_image_ctx.owner_lock.is_locked()); if (m_image_ctx.test_features(RBD_FEATURE_JOURNALING)) { assert(m_image_ctx.exclusive_lock == nullptr || @@ -866,8 +872,8 @@ int Operations::snap_unprotect(const char *snap_name) { if (m_image_ctx.test_features(RBD_FEATURE_JOURNALING)) { r = invoke_async_request("snap_unprotect", true, - boost::bind(&Operations::snap_unprotect, this, - snap_name, _1), + boost::bind(&Operations::execute_snap_unprotect, + this, snap_name, _1), boost::bind(&ImageWatcher::notify_snap_unprotect, m_image_ctx.image_watcher, snap_name, _1)); @@ -877,7 +883,7 @@ int Operations::snap_unprotect(const char *snap_name) { } else { RWLock::RLocker owner_lock(m_image_ctx.owner_lock); C_SaferCond cond_ctx; - snap_unprotect(snap_name, &cond_ctx); + execute_snap_unprotect(snap_name, &cond_ctx); r = cond_ctx.wait(); if (r < 0) { @@ -888,7 +894,8 @@ int Operations::snap_unprotect(const char *snap_name) { } template -void Operations::snap_unprotect(const char *snap_name, Context *on_finish) { +void Operations::execute_snap_unprotect(const char *snap_name, + Context *on_finish) { assert(m_image_ctx.owner_lock.is_locked()); if (m_image_ctx.test_features(RBD_FEATURE_JOURNALING)) { assert(m_image_ctx.exclusive_lock == nullptr || diff --git a/src/librbd/Operations.h b/src/librbd/Operations.h index b4ae3b431bf..b05d5da54fb 100644 --- a/src/librbd/Operations.h +++ b/src/librbd/Operations.h @@ -22,38 +22,39 @@ public: Operations(ImageCtxT &image_ctx); int flatten(ProgressContext &prog_ctx); - void flatten(ProgressContext &prog_ctx, Context *on_finish); + void execute_flatten(ProgressContext &prog_ctx, Context *on_finish); int rebuild_object_map(ProgressContext &prog_ctx); - void rebuild_object_map(ProgressContext &prog_ctx, Context *on_finish); + void execute_rebuild_object_map(ProgressContext &prog_ctx, + Context *on_finish); int rename(const char *dstname); - void rename(const char *dstname, Context *on_finish); + void execute_rename(const char *dstname, Context *on_finish); int resize(uint64_t size, ProgressContext& prog_ctx); - void resize(uint64_t size, ProgressContext &prog_ctx, Context *on_finish, - uint64_t journal_op_tid); + void execute_resize(uint64_t size, ProgressContext &prog_ctx, + Context *on_finish, uint64_t journal_op_tid); int snap_create(const char *snap_name); - void snap_create(const char *snap_name, Context *on_finish, - uint64_t journal_op_tid); + void execute_snap_create(const char *snap_name, Context *on_finish, + uint64_t journal_op_tid); int snap_rollback(const char *snap_name, ProgressContext& prog_ctx); - void snap_rollback(const char *snap_name, ProgressContext& prog_ctx, - Context *on_finish); + void execute_snap_rollback(const char *snap_name, ProgressContext& prog_ctx, + Context *on_finish); int snap_remove(const char *snap_name); - void snap_remove(const char *snap_name, Context *on_finish); + void execute_snap_remove(const char *snap_name, Context *on_finish); int snap_rename(const char *srcname, const char *dstname); - void snap_rename(const uint64_t src_snap_id, const char *dst_name, - Context *on_finish); + void execute_snap_rename(const uint64_t src_snap_id, const char *dst_name, + Context *on_finish); int snap_protect(const char *snap_name); - void snap_protect(const char *snap_name, Context *on_finish); + void execute_snap_protect(const char *snap_name, Context *on_finish); int snap_unprotect(const char *snap_name); - void snap_unprotect(const char *snap_name, Context *on_finish); + void execute_snap_unprotect(const char *snap_name, Context *on_finish); int prepare_image_update(); diff --git a/src/librbd/journal/Replay.cc b/src/librbd/journal/Replay.cc index 02625791977..55ba5f346f9 100644 --- a/src/librbd/journal/Replay.cc +++ b/src/librbd/journal/Replay.cc @@ -39,45 +39,51 @@ struct ExecuteOp : public Context { } void execute(const journal::SnapCreateEvent &_) { - image_ctx.operations->snap_create(event.snap_name.c_str(), on_op_complete, - event.op_tid); + image_ctx.operations->execute_snap_create(event.snap_name.c_str(), + on_op_complete, + event.op_tid); } void execute(const journal::SnapRemoveEvent &_) { - image_ctx.operations->snap_remove(event.snap_name.c_str(), on_op_complete); + image_ctx.operations->execute_snap_remove(event.snap_name.c_str(), + on_op_complete); } void execute(const journal::SnapRenameEvent &_) { - image_ctx.operations->snap_rename(event.snap_id, event.snap_name.c_str(), - on_op_complete); + image_ctx.operations->execute_snap_rename(event.snap_id, + event.snap_name.c_str(), + on_op_complete); } void execute(const journal::SnapProtectEvent &_) { - image_ctx.operations->snap_protect(event.snap_name.c_str(), on_op_complete); + image_ctx.operations->execute_snap_protect(event.snap_name.c_str(), + on_op_complete); } void execute(const journal::SnapUnprotectEvent &_) { - image_ctx.operations->snap_unprotect(event.snap_name.c_str(), - on_op_complete); + image_ctx.operations->execute_snap_unprotect(event.snap_name.c_str(), + on_op_complete); } void execute(const journal::SnapRollbackEvent &_) { - image_ctx.operations->snap_rollback(event.snap_name.c_str(), - no_op_progress_callback, - on_op_complete); + image_ctx.operations->execute_snap_rollback(event.snap_name.c_str(), + no_op_progress_callback, + on_op_complete); } void execute(const journal::RenameEvent &_) { - image_ctx.operations->rename(event.image_name.c_str(), on_op_complete); + image_ctx.operations->execute_rename(event.image_name.c_str(), + on_op_complete); } void execute(const journal::ResizeEvent &_) { - image_ctx.operations->resize(event.size, no_op_progress_callback, - on_op_complete, event.op_tid); + image_ctx.operations->execute_resize(event.size, no_op_progress_callback, + on_op_complete, event.op_tid); } void execute(const journal::FlattenEvent &_) { - image_ctx.operations->flatten(no_op_progress_callback, on_op_complete); + image_ctx.operations->execute_flatten(no_op_progress_callback, + on_op_complete); } virtual void finish(int r) override { diff --git a/src/test/librbd/journal/test_mock_Replay.cc b/src/test/librbd/journal/test_mock_Replay.cc index 40dc9abca0c..2fc43443347 100644 --- a/src/test/librbd/journal/test_mock_Replay.cc +++ b/src/test/librbd/journal/test_mock_Replay.cc @@ -124,21 +124,21 @@ public: } void expect_flatten(MockReplayImageCtx &mock_image_ctx, Context **on_finish) { - EXPECT_CALL(*mock_image_ctx.operations, flatten(_, _)) + EXPECT_CALL(*mock_image_ctx.operations, execute_flatten(_, _)) .WillOnce(DoAll(SaveArg<1>(on_finish), NotifyInvoke(&m_invoke_lock, &m_invoke_cond))); } void expect_rename(MockReplayImageCtx &mock_image_ctx, Context **on_finish, const char *image_name) { - EXPECT_CALL(*mock_image_ctx.operations, rename(CStrEq(image_name), _)) + EXPECT_CALL(*mock_image_ctx.operations, execute_rename(CStrEq(image_name), _)) .WillOnce(DoAll(SaveArg<1>(on_finish), NotifyInvoke(&m_invoke_lock, &m_invoke_cond))); } void expect_resize(MockReplayImageCtx &mock_image_ctx, Context **on_finish, uint64_t size, uint64_t op_tid) { - EXPECT_CALL(*mock_image_ctx.operations, resize(size, _, _, op_tid)) + EXPECT_CALL(*mock_image_ctx.operations, execute_resize(size, _, _, op_tid)) .WillOnce(DoAll(SaveArg<2>(on_finish), NotifyInvoke(&m_invoke_lock, &m_invoke_cond))); } @@ -146,15 +146,15 @@ public: void expect_snap_create(MockReplayImageCtx &mock_image_ctx, Context **on_finish, const char *snap_name, uint64_t op_tid) { - EXPECT_CALL(*mock_image_ctx.operations, snap_create(CStrEq(snap_name), _, - op_tid)) + EXPECT_CALL(*mock_image_ctx.operations, execute_snap_create(CStrEq(snap_name), _, + op_tid)) .WillOnce(DoAll(SaveArg<1>(on_finish), NotifyInvoke(&m_invoke_lock, &m_invoke_cond))); } void expect_snap_remove(MockReplayImageCtx &mock_image_ctx, Context **on_finish, const char *snap_name) { - EXPECT_CALL(*mock_image_ctx.operations, snap_remove(CStrEq(snap_name), _)) + EXPECT_CALL(*mock_image_ctx.operations, execute_snap_remove(CStrEq(snap_name), _)) .WillOnce(DoAll(SaveArg<1>(on_finish), NotifyInvoke(&m_invoke_lock, &m_invoke_cond))); } @@ -162,28 +162,28 @@ public: void expect_snap_rename(MockReplayImageCtx &mock_image_ctx, Context **on_finish, uint64_t snap_id, const char *snap_name) { - EXPECT_CALL(*mock_image_ctx.operations, snap_rename(snap_id, CStrEq(snap_name), _)) + EXPECT_CALL(*mock_image_ctx.operations, execute_snap_rename(snap_id, CStrEq(snap_name), _)) .WillOnce(DoAll(SaveArg<2>(on_finish), NotifyInvoke(&m_invoke_lock, &m_invoke_cond))); } void expect_snap_protect(MockReplayImageCtx &mock_image_ctx, Context **on_finish, const char *snap_name) { - EXPECT_CALL(*mock_image_ctx.operations, snap_protect(CStrEq(snap_name), _)) + EXPECT_CALL(*mock_image_ctx.operations, execute_snap_protect(CStrEq(snap_name), _)) .WillOnce(DoAll(SaveArg<1>(on_finish), NotifyInvoke(&m_invoke_lock, &m_invoke_cond))); } void expect_snap_unprotect(MockReplayImageCtx &mock_image_ctx, Context **on_finish, const char *snap_name) { - EXPECT_CALL(*mock_image_ctx.operations, snap_unprotect(CStrEq(snap_name), _)) + EXPECT_CALL(*mock_image_ctx.operations, execute_snap_unprotect(CStrEq(snap_name), _)) .WillOnce(DoAll(SaveArg<1>(on_finish), NotifyInvoke(&m_invoke_lock, &m_invoke_cond))); } void expect_snap_rollback(MockReplayImageCtx &mock_image_ctx, Context **on_finish, const char *snap_name) { - EXPECT_CALL(*mock_image_ctx.operations, snap_rollback(CStrEq(snap_name), _, _)) + EXPECT_CALL(*mock_image_ctx.operations, execute_snap_rollback(CStrEq(snap_name), _, _)) .WillOnce(DoAll(SaveArg<2>(on_finish), NotifyInvoke(&m_invoke_lock, &m_invoke_cond))); } diff --git a/src/test/librbd/mock/MockOperations.h b/src/test/librbd/mock/MockOperations.h index c3bf9d9ca8c..0dabac184cb 100644 --- a/src/test/librbd/mock/MockOperations.h +++ b/src/test/librbd/mock/MockOperations.h @@ -12,22 +12,29 @@ class Context; namespace librbd { struct MockOperations { - MOCK_METHOD2(flatten, void(ProgressContext &prog_ctx, Context *on_finish)); - MOCK_METHOD2(rebuild_object_map, void(ProgressContext &prog_ctx, - Context *on_finish)); - MOCK_METHOD2(rename, void(const char *dstname, Context *on_finish)); - MOCK_METHOD4(resize, void(uint64_t size, ProgressContext &prog_ctx, - Context *on_finish, uint64_t journal_op_tid)); - MOCK_METHOD3(snap_create, void(const char *snap_name, Context *on_finish, - uint64_t journal_op_tid)); - MOCK_METHOD2(snap_remove, void(const char *snap_name, Context *on_finish)); - MOCK_METHOD3(snap_rename, void(uint64_t src_snap_id, const char *snap_name, - Context *on_finish)); - MOCK_METHOD3(snap_rollback, void(const char *snap_name, - ProgressContext &prog_ctx, - Context *on_finish)); - MOCK_METHOD2(snap_protect, void(const char *snap_name, Context *on_finish)); - MOCK_METHOD2(snap_unprotect, void(const char *snap_name, Context *on_finish)); + MOCK_METHOD2(execute_flatten, void(ProgressContext &prog_ctx, + Context *on_finish)); + MOCK_METHOD2(execute_rebuild_object_map, void(ProgressContext &prog_ctx, + Context *on_finish)); + MOCK_METHOD2(execute_rename, void(const char *dstname, Context *on_finish)); + MOCK_METHOD4(execute_resize, void(uint64_t size, ProgressContext &prog_ctx, + Context *on_finish, + uint64_t journal_op_tid)); + MOCK_METHOD3(execute_snap_create, void(const char *snap_name, + Context *on_finish, + uint64_t journal_op_tid)); + MOCK_METHOD2(execute_snap_remove, void(const char *snap_name, + Context *on_finish)); + MOCK_METHOD3(execute_snap_rename, void(uint64_t src_snap_id, + const char *snap_name, + Context *on_finish)); + MOCK_METHOD3(execute_snap_rollback, void(const char *snap_name, + ProgressContext &prog_ctx, + Context *on_finish)); + MOCK_METHOD2(execute_snap_protect, void(const char *snap_name, + Context *on_finish)); + MOCK_METHOD2(execute_snap_unprotect, void(const char *snap_name, + Context *on_finish)); }; } // namespace librbd diff --git a/src/test/librbd/test_internal.cc b/src/test/librbd/test_internal.cc index c1121da7db4..b5c6f6b1ee4 100644 --- a/src/test/librbd/test_internal.cc +++ b/src/test/librbd/test_internal.cc @@ -336,7 +336,7 @@ TEST_F(TestInternal, CancelAsyncResize) { size -= MIN(size, 1<<18); { RWLock::RLocker l(ictx->owner_lock); - ictx->operations->resize(size, prog_ctx, &ctx, 0); + ictx->operations->execute_resize(size, prog_ctx, &ctx, 0); } // try to interrupt the in-progress resize @@ -384,7 +384,7 @@ TEST_F(TestInternal, MultipleResize) { RWLock::RLocker l(ictx->owner_lock); contexts.push_back(new C_SaferCond()); - ictx->operations->resize(new_size, prog_ctx, contexts.back(), 0); + ictx->operations->execute_resize(new_size, prog_ctx, contexts.back(), 0); } for (uint32_t i = 0; i < contexts.size(); ++i) { diff --git a/src/test/rbd_mirror/image_sync/test_mock_SnapshotCopyRequest.cc b/src/test/rbd_mirror/image_sync/test_mock_SnapshotCopyRequest.cc index c6752aa74c1..a8bee2ccdc8 100644 --- a/src/test/rbd_mirror/image_sync/test_mock_SnapshotCopyRequest.cc +++ b/src/test/rbd_mirror/image_sync/test_mock_SnapshotCopyRequest.cc @@ -85,7 +85,7 @@ public: void expect_snap_create(librbd::MockImageCtx &mock_image_ctx, const std::string &snap_name, uint64_t snap_id, int r) { - EXPECT_CALL(*mock_image_ctx.operations, snap_create(StrEq(snap_name), _, 0)) + EXPECT_CALL(*mock_image_ctx.operations, execute_snap_create(StrEq(snap_name), _, 0)) .WillOnce(DoAll(InvokeWithoutArgs([&mock_image_ctx, snap_id, snap_name]() { inject_snap(mock_image_ctx, snap_id, snap_name); }), @@ -96,7 +96,7 @@ public: void expect_snap_remove(librbd::MockImageCtx &mock_image_ctx, const std::string &snap_name, int r) { - EXPECT_CALL(*mock_image_ctx.operations, snap_remove(StrEq(snap_name), _)) + EXPECT_CALL(*mock_image_ctx.operations, execute_snap_remove(StrEq(snap_name), _)) .WillOnce(WithArg<1>(Invoke([this, r](Context *ctx) { m_threads->work_queue->queue(ctx, r); }))); diff --git a/src/tools/rbd_mirror/image_sync/SnapshotCopyRequest.cc b/src/tools/rbd_mirror/image_sync/SnapshotCopyRequest.cc index b53c0e1c551..ca631cf1a3e 100644 --- a/src/tools/rbd_mirror/image_sync/SnapshotCopyRequest.cc +++ b/src/tools/rbd_mirror/image_sync/SnapshotCopyRequest.cc @@ -94,7 +94,7 @@ void SnapshotCopyRequest::send_snap_remove() { SnapshotCopyRequest, &SnapshotCopyRequest::handle_snap_remove>( this); RWLock::RLocker owner_locker(m_local_image_ctx->owner_lock); - m_local_image_ctx->operations->snap_remove(m_snap_name.c_str(), ctx); + m_local_image_ctx->operations->execute_snap_remove(m_snap_name.c_str(), ctx); } template @@ -143,7 +143,8 @@ void SnapshotCopyRequest::send_snap_create() { SnapshotCopyRequest, &SnapshotCopyRequest::handle_snap_create>( this); RWLock::RLocker owner_locker(m_local_image_ctx->owner_lock); - m_local_image_ctx->operations->snap_create(m_snap_name.c_str(), ctx, 0U); + m_local_image_ctx->operations->execute_snap_create(m_snap_name.c_str(), ctx, + 0U); } template