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 <dillaman@redhat.com>

diff --git a/src/librbd/ImageWatcher.cc b/src/librbd/ImageWatcher.cc
index b6542807898435d34ce3138561b92a017346d64f..25deb8b67e74c36557f4ec52289dbb3d393e473a 100644 (file)
--- 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 e990304cc90686c7bfea86cc9107a410d8f21fc7..ef33e436fc873d22576ba74945f5ba9e498f18c8 100644 (file)
--- a/src/librbd/Operations.cc
+++ b/src/librbd/Operations.cc
@@ -235,7 +235,7 @@ int Operations<I>::flatten(ProgressContext &prog_ctx) {
 
   uint64_t request_id = ++m_async_request_seq;
   r = invoke_async_request("flatten", false,
-                           boost::bind(&Operations<I>::flatten, this,
+                           boost::bind(&Operations<I>::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<I>::flatten(ProgressContext &prog_ctx) {
 }
 
 template <typename I>
-void Operations<I>::flatten(ProgressContext &prog_ctx, Context *on_finish) {
+void Operations<I>::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<I>::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<I>::rebuild_object_map, this,
-                                       boost::ref(prog_ctx), _1),
+                           boost::bind(&Operations<I>::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<I>::rebuild_object_map(ProgressContext &prog_ctx) {
 }
 
 template <typename I>
-void Operations<I>::rebuild_object_map(ProgressContext &prog_ctx,
-                                       Context *on_finish) {
+void Operations<I>::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<I>::rename(const char *dstname) {
 
   if (m_image_ctx.test_features(RBD_FEATURE_JOURNALING)) {
     r = invoke_async_request("rename", true,
-                             boost::bind(&Operations<I>::rename, this,
+                             boost::bind(&Operations<I>::execute_rename, this,
                                          dstname, _1),
                              boost::bind(&ImageWatcher::notify_rename,
                                          m_image_ctx.image_watcher, dstname,
@@ -379,7 +380,7 @@ int Operations<I>::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<I>::rename(const char *dstname) {
 }
 
 template <typename I>
-void Operations<I>::rename(const char *dstname, Context *on_finish) {
+void Operations<I>::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<I>::resize(uint64_t size, ProgressContext& prog_ctx) {
 
   uint64_t request_id = ++m_async_request_seq;
   r = invoke_async_request("resize", false,
-                           boost::bind(&Operations<I>::resize, this,
+                           boost::bind(&Operations<I>::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<I>::resize(uint64_t size, ProgressContext& prog_ctx) {
 }
 
 template <typename I>
-void Operations<I>::resize(uint64_t size, ProgressContext &prog_ctx,
-                           Context *on_finish, uint64_t journal_op_tid) {
+void Operations<I>::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<I>::snap_create(const char *snap_name) {
   }
 
   r = invoke_async_request("snap_create", true,
-                           boost::bind(&Operations<I>::snap_create, this,
-                                       snap_name, _1, 0),
+                           boost::bind(&Operations<I>::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<I>::snap_create(const char *snap_name) {
 }
 
 template <typename I>
-void Operations<I>::snap_create(const char *snap_name, Context *on_finish,
-                                uint64_t journal_op_tid) {
+void Operations<I>::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<I>::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<I>::snap_rollback(const char *snap_name,
 }
 
 template <typename I>
-void Operations<I>::snap_rollback(const char *snap_name,
-                                  ProgressContext& prog_ctx,
-                                  Context *on_finish) {
+void Operations<I>::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<I>::snap_remove(const char *snap_name) {
 
   if (proxy_op) {
     r = invoke_async_request("snap_remove", true,
-                             boost::bind(&Operations<I>::snap_remove, this,
-                                         snap_name, _1),
+                             boost::bind(&Operations<I>::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<I>::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<I>::snap_remove(const char *snap_name) {
 }
 
 template <typename I>
-void Operations<I>::snap_remove(const char *snap_name, Context *on_finish) {
+void Operations<I>::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<I>::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<I>::snap_rename, this,
-                                         snap_id, dstname, _1),
+                             boost::bind(&Operations<I>::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<I>::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<I>::snap_rename(const char *srcname, const char *dstname) {
 }
 
 template <typename I>
-void Operations<I>::snap_rename(const uint64_t src_snap_id,
-                                const char *dst_name, Context *on_finish) {
+void Operations<I>::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<I>::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<I>::snap_protect, this,
-                                         snap_name, _1),
+                             boost::bind(&Operations<I>::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<I>::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<I>::snap_protect(const char *snap_name) {
 }
 
 template <typename I>
-void Operations<I>::snap_protect(const char *snap_name, Context *on_finish) {
+void Operations<I>::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<I>::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<I>::snap_unprotect, this,
-                                         snap_name, _1),
+                             boost::bind(&Operations<I>::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<I>::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<I>::snap_unprotect(const char *snap_name) {
 }
 
 template <typename I>
-void Operations<I>::snap_unprotect(const char *snap_name, Context *on_finish) {
+void Operations<I>::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 b4ae3b431bfa0059ca9a5aab4a363b0d2c05736d..b05d5da54fb13ed6303a807940d8418e728bd01b 100644 (file)
--- 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 02625791977e42181b8b562c098d7a272e51166f..55ba5f346f9c13d3b0c5c4a8badb065e42a8bfb8 100644 (file)
--- 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 40dc9abca0cff8eb741bcdf037eccd5b49da38c1..2fc4344334775e424de8dce90022223b496e81bf 100644 (file)
--- 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 c3bf9d9ca8c3dd6a037fd0f825c2bfab84b07057..0dabac184cb278105bc60d45fcba6015da20e73a 100644 (file)
--- 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 c1121da7db4ffecc12e680354725ef9518c07c9e..b5c6f6b1ee43808bac0f7a35c28de1648eaf4756 100644 (file)
--- 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 c6752aa74c17fe9ea392ec0bc20ddceddf177be0..a8bee2ccdc8b8ef73e5542cefe388ff42d96374a 100644 (file)
--- 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 b53c0e1c551326bf67b072f8430696095faeb01e..ca631cf1a3e696b05bf18aba8a3e7d9d4b7abba8 100644 (file)
--- a/src/tools/rbd_mirror/image_sync/SnapshotCopyRequest.cc
+++ b/src/tools/rbd_mirror/image_sync/SnapshotCopyRequest.cc
@@ -94,7 +94,7 @@ void SnapshotCopyRequest<I>::send_snap_remove() {
     SnapshotCopyRequest<I>, &SnapshotCopyRequest<I>::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 <typename I>
@@ -143,7 +143,8 @@ void SnapshotCopyRequest<I>::send_snap_create() {
     SnapshotCopyRequest<I>, &SnapshotCopyRequest<I>::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 <typename I>