librbd: deep_copy: move set_head to snapshot_copy state machine

Signed-off-by: Mykola Golub <to.my.trociny@gmail.com>

diff --git a/src/librbd/DeepCopyRequest.cc b/src/librbd/DeepCopyRequest.cc
index 9c10724e571735fd617637ea65118ba262862042..b5983e9efded6a953a56c3ecfced7a93c4c43a4d 100644 (file)
--- a/src/librbd/DeepCopyRequest.cc
+++ b/src/librbd/DeepCopyRequest.cc
@@ -10,7 +10,6 @@
 #include "librbd/Utils.h"
 #include "librbd/deep_copy/ImageCopyRequest.h"
 #include "librbd/deep_copy/MetadataCopyRequest.h"
-#include "librbd/deep_copy/SetHeadRequest.h"
 #include "librbd/deep_copy/SnapshotCopyRequest.h"
 #include "librbd/internal.h"
 
@@ -123,54 +122,6 @@ void DeepCopyRequest<I>::handle_copy_snapshots(int r) {
     return;
   }
 
-  send_set_head();
-}
-
-template <typename I>
-void DeepCopyRequest<I>::send_set_head() {
-  if (m_snap_id_end != CEPH_NOSNAP) {
-    send_copy_image();
-    return;
-  }
-
-  ldout(m_cct, 20) << dendl;
-
-  uint64_t size;
-  ParentSpec parent_spec;
-  uint64_t parent_overlap;
-  {
-    RWLock::RLocker src_locker(m_src_image_ctx->snap_lock);
-    size = m_src_image_ctx->size;
-    parent_spec = m_src_image_ctx->parent_md.spec;
-    parent_overlap = m_src_image_ctx->parent_md.overlap;
-  }
-
-  auto ctx = create_context_callback<
-    DeepCopyRequest<I>, &DeepCopyRequest<I>::handle_set_head>(this);
-  auto req = SetHeadRequest<I>::create(m_dst_image_ctx, size, parent_spec,
-                                       parent_overlap, ctx);
-  req->send();
-}
-
-template <typename I>
-void DeepCopyRequest<I>::handle_set_head(int r) {
-  ldout(m_cct, 20) << "r=" << r << dendl;
-
-  {
-    Mutex::Locker locker(m_lock);
-    if (r == 0 && m_canceled) {
-      r = -ECANCELED;
-    }
-  }
-
-  if (r < 0) {
-    if (r != -ECANCELED) {
-      lderr(m_cct) << "failed to set head: " << cpp_strerror(r) << dendl;
-    }
-    finish(r);
-    return;
-  }
-
   send_copy_image();
 }
 

diff --git a/src/librbd/DeepCopyRequest.h b/src/librbd/DeepCopyRequest.h
index e48527c94df4505ef8a9cf7e3651759de565f35b..553f575f7f8a46198120012d38036595a39549ee 100644 (file)
--- a/src/librbd/DeepCopyRequest.h
+++ b/src/librbd/DeepCopyRequest.h
@@ -64,9 +64,6 @@ private:
    * COPY_SNAPSHOTS
    *    |
    *    v
-   * SET_HEAD (skip if not needed)
-   *    |
-   *    v
    * COPY_IMAGE . . . . . . . . . . . . . .
    *    |                                 .
    *    v                                 .
@@ -108,9 +105,6 @@ private:
   void send_copy_snapshots();
   void handle_copy_snapshots(int r);
 
-  void send_set_head();
-  void handle_set_head(int r);
-
   void send_copy_image();
   void handle_copy_image(int r);
 

diff --git a/src/librbd/deep_copy/SnapshotCopyRequest.cc b/src/librbd/deep_copy/SnapshotCopyRequest.cc
index fbd726838ebc0f4bd6fd9ae6874562954c814bef..4f5edd39e42cc33a623a15846a1fa8a07f490267 100644 (file)
--- a/src/librbd/deep_copy/SnapshotCopyRequest.cc
+++ b/src/librbd/deep_copy/SnapshotCopyRequest.cc
@@ -2,6 +2,7 @@
 // vim: ts=8 sw=2 smarttab
 
 #include "SnapshotCopyRequest.h"
+#include "SetHeadRequest.h"
 #include "SnapshotCreateRequest.h"
 #include "common/errno.h"
 #include "common/WorkQueue.h"
@@ -36,6 +37,7 @@ const std::string &get_snapshot_name(I *image_ctx, librados::snap_t snap_id) {
 
 } // anonymous namespace
 
+using librbd::util::create_context_callback;
 using librbd::util::unique_lock_name;
 
 template <typename I>
@@ -461,7 +463,7 @@ void SnapshotCopyRequest<I>::send_snap_protect() {
   if (snap_id_it == m_src_snap_ids.end()) {
     // no destination snapshots to protect
     m_prev_snap_id = CEPH_NOSNAP;
-    finish(0);
+    send_set_head();
     return;
   }
 
@@ -504,6 +506,45 @@ void SnapshotCopyRequest<I>::handle_snap_protect(int r) {
   send_snap_protect();
 }
 
+template <typename I>
+void SnapshotCopyRequest<I>::send_set_head() {
+  if (m_snap_id_end != CEPH_NOSNAP) {
+    finish(0);
+    return;
+  }
+
+  ldout(m_cct, 20) << dendl;
+
+  uint64_t size;
+  ParentSpec parent_spec;
+  uint64_t parent_overlap;
+  {
+    RWLock::RLocker src_locker(m_src_image_ctx->snap_lock);
+    size = m_src_image_ctx->size;
+    parent_spec = m_src_image_ctx->parent_md.spec;
+    parent_overlap = m_src_image_ctx->parent_md.overlap;
+  }
+
+  auto ctx = create_context_callback<
+    SnapshotCopyRequest<I>, &SnapshotCopyRequest<I>::handle_set_head>(this);
+  auto req = SetHeadRequest<I>::create(m_dst_image_ctx, size, parent_spec,
+                                       parent_overlap, ctx);
+  req->send();
+}
+
+template <typename I>
+void SnapshotCopyRequest<I>::handle_set_head(int r) {
+  ldout(m_cct, 20) << "r=" << r << dendl;
+
+  if (r < 0) {
+    lderr(m_cct) << "failed to set head: " << cpp_strerror(r) << dendl;
+    finish(r);
+    return;
+  }
+
+  finish(0);
+}
+
 template <typename I>
 bool SnapshotCopyRequest<I>::handle_cancellation() {
   {

diff --git a/src/librbd/deep_copy/SnapshotCopyRequest.h b/src/librbd/deep_copy/SnapshotCopyRequest.h
index 6c5c521d1dd60b0487437556a6cc80d13155cb61..47ab83e4982aa734940a62a548cddc23a66165c3 100644 (file)
--- a/src/librbd/deep_copy/SnapshotCopyRequest.h
+++ b/src/librbd/deep_copy/SnapshotCopyRequest.h
@@ -67,6 +67,9 @@ private:
    * PROTECT_SNAP ------/
    *    |
    *    v
+   * SET_HEAD (skip if not needed)
+   *    |
+   *    v
    * <finish>
    *
    * @endverbatim
@@ -107,6 +110,9 @@ private:
   void send_snap_protect();
   void handle_snap_protect(int r);
 
+  void send_set_head();
+  void handle_set_head(int r);
+
   bool handle_cancellation();
 
   void error(int r);

diff --git a/src/test/librbd/deep_copy/test_mock_SnapshotCopyRequest.cc b/src/test/librbd/deep_copy/test_mock_SnapshotCopyRequest.cc
index 8ba7d82b83e55f8c0649f4c6b8e538b74f6da6c1..ffed8f3f656eca75a81b10930fdaee6997f388b6 100644 (file)
--- a/src/test/librbd/deep_copy/test_mock_SnapshotCopyRequest.cc
+++ b/src/test/librbd/deep_copy/test_mock_SnapshotCopyRequest.cc
@@ -6,6 +6,7 @@
 #include "librbd/ImageCtx.h"
 #include "librbd/ImageState.h"
 #include "librbd/Operations.h"
+#include "librbd/deep_copy/SetHeadRequest.h"
 #include "librbd/deep_copy/SnapshotCopyRequest.h"
 #include "librbd/deep_copy/SnapshotCreateRequest.h"
 #include "test/librados_test_stub/MockTestMemIoCtxImpl.h"
@@ -26,6 +27,28 @@ struct MockTestImageCtx : public librbd::MockImageCtx {
 
 namespace deep_copy {
 
+template <>
+class SetHeadRequest<librbd::MockTestImageCtx> {
+public:
+  static SetHeadRequest* s_instance;
+  Context *on_finish;
+
+  static SetHeadRequest* create(librbd::MockTestImageCtx *image_ctx,
+                                uint64_t size,
+                                const librbd::ParentSpec &parent_spec,
+                                uint64_t parent_overlap, Context *on_finish) {
+    assert(s_instance != nullptr);
+    s_instance->on_finish = on_finish;
+    return s_instance;
+  }
+
+  SetHeadRequest() {
+    s_instance = this;
+  }
+
+  MOCK_METHOD0(send, void());
+};
+
 template <>
 struct SnapshotCreateRequest<librbd::MockTestImageCtx> {
   static SnapshotCreateRequest* s_instance;
@@ -50,6 +73,7 @@ struct SnapshotCreateRequest<librbd::MockTestImageCtx> {
   MOCK_METHOD0(send, void());
 };
 
+SetHeadRequest<librbd::MockTestImageCtx>* SetHeadRequest<librbd::MockTestImageCtx>::s_instance = nullptr;
 SnapshotCreateRequest<librbd::MockTestImageCtx>* SnapshotCreateRequest<librbd::MockTestImageCtx>::s_instance = nullptr;
 
 } // namespace deep_copy
@@ -76,6 +100,7 @@ using ::testing::WithArg;
 
 class TestMockDeepCopySnapshotCopyRequest : public TestMockFixture {
 public:
+  typedef SetHeadRequest<librbd::MockTestImageCtx> MockSetHeadRequest;
   typedef SnapshotCopyRequest<librbd::MockTestImageCtx> MockSnapshotCopyRequest;
   typedef SnapshotCreateRequest<librbd::MockTestImageCtx> MockSnapshotCreateRequest;
 
@@ -180,6 +205,13 @@ public:
                                   Return(r)));
   }
 
+  void expect_set_head(MockSetHeadRequest &mock_set_head_request, int r) {
+    EXPECT_CALL(mock_set_head_request, send())
+      .WillOnce(Invoke([this, &mock_set_head_request, r]() {
+            mock_set_head_request.on_finish->complete(r);
+          }));
+  }
+
   static void inject_snap(librbd::MockTestImageCtx &mock_image_ctx,
                           uint64_t snap_id, const std::string &snap_name) {
     mock_image_ctx.snap_ids[{cls::rbd::UserSnapshotNamespace(),
@@ -188,9 +220,10 @@ public:
 
   MockSnapshotCopyRequest *create_request(
       librbd::MockTestImageCtx &mock_src_image_ctx,
-      librbd::MockTestImageCtx &mock_dst_image_ctx, Context *on_finish) {
+      librbd::MockTestImageCtx &mock_dst_image_ctx, Context *on_finish,
+      librados::snap_t snap_id_end = CEPH_NOSNAP) {
     return new MockSnapshotCopyRequest(&mock_src_image_ctx, &mock_dst_image_ctx,
-                                       CEPH_NOSNAP, m_work_queue, &m_snap_seqs,
+                                       snap_id_end, m_work_queue, &m_snap_seqs,
                                        on_finish);
   }
 
@@ -225,6 +258,7 @@ public:
 TEST_F(TestMockDeepCopySnapshotCopyRequest, Empty) {
   librbd::MockTestImageCtx mock_src_image_ctx(*m_src_image_ctx);
   librbd::MockTestImageCtx mock_dst_image_ctx(*m_dst_image_ctx);
+  MockSetHeadRequest mock_set_head_request;
 
   librbd::MockExclusiveLock mock_exclusive_lock;
   prepare_exclusive_lock(mock_dst_image_ctx, mock_exclusive_lock);
@@ -232,6 +266,7 @@ TEST_F(TestMockDeepCopySnapshotCopyRequest, Empty) {
   expect_test_features(mock_dst_image_ctx);
 
   InSequence seq;
+  expect_set_head(mock_set_head_request, 0);
 
   C_SaferCond ctx;
   MockSnapshotCopyRequest *request = create_request(mock_src_image_ctx,
@@ -254,6 +289,7 @@ TEST_F(TestMockDeepCopySnapshotCopyRequest, SnapCreate) {
   librbd::MockTestImageCtx mock_src_image_ctx(*m_src_image_ctx);
   librbd::MockTestImageCtx mock_dst_image_ctx(*m_dst_image_ctx);
   MockSnapshotCreateRequest mock_snapshot_create_request;
+  MockSetHeadRequest mock_set_head_request;
 
   librbd::MockExclusiveLock mock_exclusive_lock;
   prepare_exclusive_lock(mock_dst_image_ctx, mock_exclusive_lock);
@@ -269,6 +305,7 @@ TEST_F(TestMockDeepCopySnapshotCopyRequest, SnapCreate) {
   expect_snap_create(mock_dst_image_ctx, mock_snapshot_create_request, "snap2", 14, 0);
   expect_snap_is_protected(mock_src_image_ctx, src_snap_id1, false, 0);
   expect_snap_is_protected(mock_src_image_ctx, src_snap_id2, false, 0);
+  expect_set_head(mock_set_head_request, 0);
 
   C_SaferCond ctx;
   MockSnapshotCopyRequest *request = create_request(mock_src_image_ctx,
@@ -352,6 +389,7 @@ TEST_F(TestMockDeepCopySnapshotCopyRequest, SnapRemoveAndCreate) {
   librbd::MockTestImageCtx mock_src_image_ctx(*m_src_image_ctx);
   librbd::MockTestImageCtx mock_dst_image_ctx(*m_dst_image_ctx);
   MockSnapshotCreateRequest mock_snapshot_create_request;
+  MockSetHeadRequest mock_set_head_request;
 
   librbd::MockExclusiveLock mock_exclusive_lock;
   prepare_exclusive_lock(mock_dst_image_ctx, mock_exclusive_lock);
@@ -370,6 +408,7 @@ TEST_F(TestMockDeepCopySnapshotCopyRequest, SnapRemoveAndCreate) {
   expect_start_op(mock_exclusive_lock);
   expect_snap_create(mock_dst_image_ctx, mock_snapshot_create_request, "snap1", 12, 0);
   expect_snap_is_protected(mock_src_image_ctx, src_snap_id1, false, 0);
+  expect_set_head(mock_set_head_request, 0);
 
   C_SaferCond ctx;
   MockSnapshotCopyRequest *request = create_request(mock_src_image_ctx,
@@ -424,6 +463,7 @@ TEST_F(TestMockDeepCopySnapshotCopyRequest, SnapUnprotect) {
 
   librbd::MockTestImageCtx mock_src_image_ctx(*m_src_image_ctx);
   librbd::MockTestImageCtx mock_dst_image_ctx(*m_dst_image_ctx);
+  MockSetHeadRequest mock_set_head_request;
 
   librbd::MockExclusiveLock mock_exclusive_lock;
   prepare_exclusive_lock(mock_dst_image_ctx, mock_exclusive_lock);
@@ -438,6 +478,7 @@ TEST_F(TestMockDeepCopySnapshotCopyRequest, SnapUnprotect) {
   expect_get_snap_namespace(mock_dst_image_ctx, dst_snap_id1);
   expect_get_snap_namespace(mock_src_image_ctx, src_snap_id1);
   expect_snap_is_protected(mock_src_image_ctx, src_snap_id1, false, 0);
+  expect_set_head(mock_set_head_request, 0);
 
   C_SaferCond ctx;
   MockSnapshotCopyRequest *request = create_request(mock_src_image_ctx,
@@ -535,6 +576,7 @@ TEST_F(TestMockDeepCopySnapshotCopyRequest, SnapUnprotectRemove) {
   librbd::MockTestImageCtx mock_src_image_ctx(*m_src_image_ctx);
   librbd::MockTestImageCtx mock_dst_image_ctx(*m_dst_image_ctx);
   MockSnapshotCreateRequest mock_snapshot_create_request;
+  MockSetHeadRequest mock_set_head_request;
 
   librbd::MockExclusiveLock mock_exclusive_lock;
   prepare_exclusive_lock(mock_dst_image_ctx, mock_exclusive_lock);
@@ -556,6 +598,7 @@ TEST_F(TestMockDeepCopySnapshotCopyRequest, SnapUnprotectRemove) {
   expect_snap_create(mock_dst_image_ctx, mock_snapshot_create_request, "snap1",
                      12, 0);
   expect_snap_is_protected(mock_src_image_ctx, src_snap_id1, false, 0);
+  expect_set_head(mock_set_head_request, 0);
 
   C_SaferCond ctx;
   MockSnapshotCopyRequest *request = create_request(mock_src_image_ctx,
@@ -577,6 +620,7 @@ TEST_F(TestMockDeepCopySnapshotCopyRequest, SnapCreateProtect) {
   librbd::MockTestImageCtx mock_src_image_ctx(*m_src_image_ctx);
   librbd::MockTestImageCtx mock_dst_image_ctx(*m_dst_image_ctx);
   MockSnapshotCreateRequest mock_snapshot_create_request;
+  MockSetHeadRequest mock_set_head_request;
 
   librbd::MockExclusiveLock mock_exclusive_lock;
   prepare_exclusive_lock(mock_dst_image_ctx, mock_exclusive_lock);
@@ -592,6 +636,7 @@ TEST_F(TestMockDeepCopySnapshotCopyRequest, SnapCreateProtect) {
   expect_snap_is_protected(mock_dst_image_ctx, 12, false, 0);
   expect_start_op(mock_exclusive_lock);
   expect_snap_protect(mock_dst_image_ctx, "snap1", 0);
+  expect_set_head(mock_set_head_request, 0);
 
   C_SaferCond ctx;
   MockSnapshotCopyRequest *request = create_request(mock_src_image_ctx,
@@ -616,6 +661,7 @@ TEST_F(TestMockDeepCopySnapshotCopyRequest, SnapProtect) {
 
   librbd::MockTestImageCtx mock_src_image_ctx(*m_src_image_ctx);
   librbd::MockTestImageCtx mock_dst_image_ctx(*m_dst_image_ctx);
+  MockSetHeadRequest mock_set_head_request;
 
   librbd::MockExclusiveLock mock_exclusive_lock;
   prepare_exclusive_lock(mock_dst_image_ctx, mock_exclusive_lock);
@@ -630,6 +676,7 @@ TEST_F(TestMockDeepCopySnapshotCopyRequest, SnapProtect) {
   expect_snap_is_protected(mock_dst_image_ctx, dst_snap_id1, false, 0);
   expect_start_op(mock_exclusive_lock);
   expect_snap_protect(mock_dst_image_ctx, "snap1", 0);
+  expect_set_head(mock_set_head_request, 0);
 
   C_SaferCond ctx;
   MockSnapshotCopyRequest *request = create_request(mock_src_image_ctx,
@@ -719,5 +766,59 @@ TEST_F(TestMockDeepCopySnapshotCopyRequest, SnapProtectCancel) {
   ASSERT_EQ(-ECANCELED, ctx.wait());
 }
 
+TEST_F(TestMockDeepCopySnapshotCopyRequest, SetHeadError) {
+  librbd::MockTestImageCtx mock_src_image_ctx(*m_src_image_ctx);
+  librbd::MockTestImageCtx mock_dst_image_ctx(*m_dst_image_ctx);
+  MockSetHeadRequest mock_set_head_request;
+
+  librbd::MockExclusiveLock mock_exclusive_lock;
+  prepare_exclusive_lock(mock_dst_image_ctx, mock_exclusive_lock);
+
+  expect_test_features(mock_dst_image_ctx);
+
+  InSequence seq;
+  expect_set_head(mock_set_head_request, -EINVAL);
+
+  C_SaferCond ctx;
+  MockSnapshotCopyRequest *request = create_request(mock_src_image_ctx,
+                                                    mock_dst_image_ctx, &ctx);
+  request->send();
+  ASSERT_EQ(-EINVAL, ctx.wait());
+}
+
+TEST_F(TestMockDeepCopySnapshotCopyRequest, NoSetHead) {
+  REQUIRE_FEATURE(RBD_FEATURE_LAYERING);
+
+  ASSERT_EQ(0, create_snap(m_src_image_ctx, "snap1", true));
+
+  uint64_t src_snap_id1 = m_src_image_ctx->snap_ids[
+    {cls::rbd::UserSnapshotNamespace(), "snap1"}];
+
+  librbd::MockTestImageCtx mock_src_image_ctx(*m_src_image_ctx);
+  librbd::MockTestImageCtx mock_dst_image_ctx(*m_dst_image_ctx);
+  MockSnapshotCreateRequest mock_snapshot_create_request;
+
+  librbd::MockExclusiveLock mock_exclusive_lock;
+  prepare_exclusive_lock(mock_dst_image_ctx, mock_exclusive_lock);
+
+  expect_test_features(mock_dst_image_ctx);
+
+  InSequence seq;
+  expect_get_snap_namespace(mock_src_image_ctx, src_snap_id1);
+  expect_start_op(mock_exclusive_lock);
+  expect_snap_create(mock_dst_image_ctx, mock_snapshot_create_request, "snap1",
+                     12, 0);
+  expect_snap_is_protected(mock_src_image_ctx, src_snap_id1, false, 0);
+
+  C_SaferCond ctx;
+  MockSnapshotCopyRequest *request = create_request(mock_src_image_ctx,
+                                                    mock_dst_image_ctx, &ctx,
+                                                    src_snap_id1);
+  request->send();
+  ASSERT_EQ(0, ctx.wait());
+
+  validate_snap_seqs({{src_snap_id1, 12}});
+}
+
 } // namespace deep_copy
 } // namespace librbd

diff --git a/src/test/librbd/test_mock_DeepCopyRequest.cc b/src/test/librbd/test_mock_DeepCopyRequest.cc
index bc3542296d76e4352ddf5c4a5bb46ebee76bbc91..da8bdecdabab5a5e9bde5fc23a028af410272ba7 100644 (file)
--- a/src/test/librbd/test_mock_DeepCopyRequest.cc
+++ b/src/test/librbd/test_mock_DeepCopyRequest.cc
@@ -9,7 +9,6 @@
 #include "librbd/internal.h"
 #include "librbd/deep_copy/ImageCopyRequest.h"
 #include "librbd/deep_copy/MetadataCopyRequest.h"
-#include "librbd/deep_copy/SetHeadRequest.h"
 #include "librbd/deep_copy/SnapshotCopyRequest.h"
 #include "test/librbd/mock/MockImageCtx.h"
 #include "test/librbd/mock/MockObjectMap.h"
@@ -84,28 +83,6 @@ public:
   MOCK_METHOD0(send, void());
 };
 
-template <>
-class SetHeadRequest<librbd::MockTestImageCtx> {
-public:
-  static SetHeadRequest* s_instance;
-  Context *on_finish;
-
-  static SetHeadRequest* create(librbd::MockTestImageCtx *image_ctx,
-                                uint64_t size,
-                                const librbd::ParentSpec &parent_spec,
-                                uint64_t parent_overlap, Context *on_finish) {
-    assert(s_instance != nullptr);
-    s_instance->on_finish = on_finish;
-    return s_instance;
-  }
-
-  SetHeadRequest() {
-    s_instance = this;
-  }
-
-  MOCK_METHOD0(send, void());
-};
-
 template <>
 class SnapshotCopyRequest<librbd::MockTestImageCtx> {
 public:
@@ -138,7 +115,6 @@ public:
 
 ImageCopyRequest<librbd::MockTestImageCtx>* ImageCopyRequest<librbd::MockTestImageCtx>::s_instance = nullptr;
 MetadataCopyRequest<librbd::MockTestImageCtx>* MetadataCopyRequest<librbd::MockTestImageCtx>::s_instance = nullptr;
-SetHeadRequest<librbd::MockTestImageCtx>* SetHeadRequest<librbd::MockTestImageCtx>::s_instance = nullptr;
 SnapshotCopyRequest<librbd::MockTestImageCtx>* SnapshotCopyRequest<librbd::MockTestImageCtx>::s_instance = nullptr;
 
 } // namespace deep_copy
@@ -161,7 +137,6 @@ public:
   typedef librbd::DeepCopyRequest<librbd::MockTestImageCtx> MockDeepCopyRequest;
   typedef librbd::deep_copy::ImageCopyRequest<librbd::MockTestImageCtx> MockImageCopyRequest;
   typedef librbd::deep_copy::MetadataCopyRequest<librbd::MockTestImageCtx> MockMetadataCopyRequest;
-  typedef librbd::deep_copy::SetHeadRequest<librbd::MockTestImageCtx> MockSetHeadRequest;
   typedef librbd::deep_copy::SnapshotCopyRequest<librbd::MockTestImageCtx> MockSnapshotCopyRequest;
 
   librbd::ImageCtx *m_src_image_ctx;
@@ -226,13 +201,6 @@ public:
           }));
   }
 
-  void expect_set_head(MockSetHeadRequest &mock_set_head_request, int r) {
-    EXPECT_CALL(mock_set_head_request, send())
-      .WillOnce(Invoke([this, &mock_set_head_request, r]() {
-            mock_set_head_request.on_finish->complete(r);
-          }));
-  }
-
   void expect_copy_image(MockImageCopyRequest &mock_image_copy_request, int r) {
     EXPECT_CALL(mock_image_copy_request, send())
       .WillOnce(Invoke([this, &mock_image_copy_request, r]() {
@@ -267,7 +235,6 @@ TEST_F(TestMockDeepCopyRequest, SimpleCopy) {
   librbd::MockTestImageCtx mock_dst_image_ctx(*m_dst_image_ctx);
   MockImageCopyRequest mock_image_copy_request;
   MockMetadataCopyRequest mock_metadata_copy_request;
-  MockSetHeadRequest mock_set_head_request;
   MockSnapshotCopyRequest mock_snapshot_copy_request;
 
   librbd::MockExclusiveLock mock_exclusive_lock;
@@ -282,7 +249,6 @@ TEST_F(TestMockDeepCopyRequest, SimpleCopy) {
 
   InSequence seq;
   expect_copy_snapshots(mock_snapshot_copy_request, 0);
-  expect_set_head(mock_set_head_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);
@@ -317,36 +283,14 @@ TEST_F(TestMockDeepCopyRequest, ErrorOnCopySnapshots) {
   ASSERT_EQ(-EINVAL, ctx.wait());
 }
 
-TEST_F(TestMockDeepCopyRequest, ErrorOnSetHead) {
-  librbd::MockTestImageCtx mock_src_image_ctx(*m_src_image_ctx);
-  librbd::MockTestImageCtx mock_dst_image_ctx(*m_dst_image_ctx);
-  MockSetHeadRequest mock_set_head_request;
-  MockSnapshotCopyRequest mock_snapshot_copy_request;
-
-  InSequence seq;
-  expect_copy_snapshots(mock_snapshot_copy_request, 0);
-  expect_set_head(mock_set_head_request, -EINVAL);
-
-  C_SaferCond ctx;
-  librbd::SnapSeqs snap_seqs;
-  librbd::NoOpProgressContext no_op;
-  auto request = librbd::DeepCopyRequest<librbd::MockTestImageCtx>::create(
-      &mock_src_image_ctx, &mock_dst_image_ctx, 0, CEPH_NOSNAP, boost::none,
-      m_work_queue, &snap_seqs, &no_op, &ctx);
-  request->send();
-  ASSERT_EQ(-EINVAL, ctx.wait());
-}
-
 TEST_F(TestMockDeepCopyRequest, ErrorOnCopyImage) {
   librbd::MockTestImageCtx mock_src_image_ctx(*m_src_image_ctx);
   librbd::MockTestImageCtx mock_dst_image_ctx(*m_dst_image_ctx);
   MockImageCopyRequest mock_image_copy_request;
-  MockSetHeadRequest mock_set_head_request;
   MockSnapshotCopyRequest mock_snapshot_copy_request;
 
   InSequence seq;
   expect_copy_snapshots(mock_snapshot_copy_request, 0);
-  expect_set_head(mock_set_head_request, 0);
   expect_copy_image(mock_image_copy_request, -EINVAL);
 
   C_SaferCond ctx;
@@ -364,7 +308,6 @@ TEST_F(TestMockDeepCopyRequest, ErrorOnCopyMetadata) {
   librbd::MockTestImageCtx mock_dst_image_ctx(*m_dst_image_ctx);
   MockImageCopyRequest mock_image_copy_request;
   MockMetadataCopyRequest mock_metadata_copy_request;
-  MockSetHeadRequest mock_set_head_request;
   MockSnapshotCopyRequest mock_snapshot_copy_request;
 
   librbd::MockExclusiveLock mock_exclusive_lock;
@@ -379,7 +322,6 @@ TEST_F(TestMockDeepCopyRequest, ErrorOnCopyMetadata) {
 
   InSequence seq;
   expect_copy_snapshots(mock_snapshot_copy_request, 0);
-  expect_set_head(mock_set_head_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);