rbd-mirror: consolidate prepare local/remote image steps to bootstrap

Now that the bootstrap state machine is simplier, it makes it cleaner to
move the prepare steps into the bootstrap state machine. Once snapshot
mirror support is added, these prepare state can be swapped out depending
on the mirroring type.

Signed-off-by: Jason Dillaman <dillaman@redhat.com>

8 files changed, 687 insertions, 659 deletions

diff --git a/src/test/rbd_mirror/image_replayer/test_mock_BootstrapRequest.cc b/src/test/rbd_mirror/image_replayer/test_mock_BootstrapRequest.cc
index 7e0212210c8..1f7072edb82 100644
--- a/src/test/rbd_mirror/image_replayer/test_mock_BootstrapRequest.cc
+++ b/src/test/rbd_mirror/image_replayer/test_mock_BootstrapRequest.cc
@@ -10,6 +10,8 @@
 #include "tools/rbd_mirror/image_replayer/CloseImageRequest.h"
 #include "tools/rbd_mirror/image_replayer/OpenImageRequest.h"
 #include "tools/rbd_mirror/image_replayer/OpenLocalImageRequest.h"
+#include "tools/rbd_mirror/image_replayer/PrepareLocalImageRequest.h"
+#include "tools/rbd_mirror/image_replayer/PrepareRemoteImageRequest.h"
 #include "tools/rbd_mirror/image_replayer/journal/CreateLocalImageRequest.h"
 #include "tools/rbd_mirror/image_replayer/journal/PrepareReplayRequest.h"
 #include "test/journal/mock/MockJournaler.h"
@@ -220,12 +222,86 @@ struct OpenLocalImageRequest<librbd::MockTestImageCtx> {
   MOCK_METHOD0(send, void());
 };
 
+template<>
+struct PrepareLocalImageRequest<librbd::MockTestImageCtx> {
+  static PrepareLocalImageRequest* s_instance;
+  std::string *local_image_id = nullptr;
+  std::string *local_image_name = nullptr;
+  std::string *tag_owner = nullptr;
+  Context *on_finish = nullptr;
+
+  static PrepareLocalImageRequest* create(librados::IoCtx &,
+                                          const std::string &global_image_id,
+                                          std::string *local_image_id,
+                                          std::string *local_image_name,
+                                          std::string *tag_owner,
+                                          ContextWQ *work_queue,
+                                          Context *on_finish) {
+    ceph_assert(s_instance != nullptr);
+    s_instance->local_image_id = local_image_id;
+    s_instance->local_image_name = local_image_name;
+    s_instance->tag_owner = tag_owner;
+    s_instance->on_finish = on_finish;
+    return s_instance;
+  }
+
+  PrepareLocalImageRequest() {
+    s_instance = this;
+  }
+
+  MOCK_METHOD0(send, void());
+};
+
+template<>
+struct PrepareRemoteImageRequest<librbd::MockTestImageCtx> {
+  static PrepareRemoteImageRequest* s_instance;
+  std::string *remote_mirror_uuid = nullptr;
+  std::string *remote_image_id = nullptr;
+  ::journal::MockJournaler **remote_journaler = nullptr;
+  cls::journal::ClientState *client_state;
+  librbd::journal::MirrorPeerClientMeta *client_meta = nullptr;
+  Context *on_finish = nullptr;
+
+  static PrepareRemoteImageRequest* create(Threads<librbd::MockTestImageCtx> *threads,
+                                           librados::IoCtx &,
+                                           const std::string &global_image_id,
+                                           const std::string &local_mirror_uuid,
+                                           const std::string &local_image_id,
+                                           const ::journal::Settings &settings,
+                                           ::journal::CacheManagerHandler *cache_manager_handler,
+                                           std::string *remote_mirror_uuid,
+                                           std::string *remote_image_id,
+                                           ::journal::MockJournaler **remote_journaler,
+                                           cls::journal::ClientState *client_state,
+                                           librbd::journal::MirrorPeerClientMeta *client_meta,
+                                           Context *on_finish) {
+    ceph_assert(s_instance != nullptr);
+    s_instance->remote_mirror_uuid = remote_mirror_uuid;
+    s_instance->remote_image_id = remote_image_id;
+    s_instance->remote_journaler = remote_journaler;
+    s_instance->client_state = client_state;
+    s_instance->client_meta = client_meta;
+    s_instance->on_finish = on_finish;
+    return s_instance;
+  }
+
+  PrepareRemoteImageRequest() {
+    s_instance = this;
+  }
+
+  MOCK_METHOD0(send, void());
+};
+
 CloseImageRequest<librbd::MockTestImageCtx>*
   CloseImageRequest<librbd::MockTestImageCtx>::s_instance = nullptr;
 OpenImageRequest<librbd::MockTestImageCtx>*
   OpenImageRequest<librbd::MockTestImageCtx>::s_instance = nullptr;
 OpenLocalImageRequest<librbd::MockTestImageCtx>*
   OpenLocalImageRequest<librbd::MockTestImageCtx>::s_instance = nullptr;
+PrepareLocalImageRequest<librbd::MockTestImageCtx>*
+  PrepareLocalImageRequest<librbd::MockTestImageCtx>::s_instance = nullptr;
+PrepareRemoteImageRequest<librbd::MockTestImageCtx>*
+  PrepareRemoteImageRequest<librbd::MockTestImageCtx>::s_instance = nullptr;
 
 namespace journal {
 
@@ -339,6 +415,8 @@ public:
   typedef InstanceWatcher<librbd::MockTestImageCtx> MockInstanceWatcher;
   typedef OpenImageRequest<librbd::MockTestImageCtx> MockOpenImageRequest;
   typedef OpenLocalImageRequest<librbd::MockTestImageCtx> MockOpenLocalImageRequest;
+  typedef PrepareLocalImageRequest<librbd::MockTestImageCtx> MockPrepareLocalImageRequest;
+  typedef PrepareRemoteImageRequest<librbd::MockTestImageCtx> MockPrepareRemoteImageRequest;
   typedef journal::CreateLocalImageRequest<librbd::MockTestImageCtx> MockCreateLocalImageRequest;
   typedef journal::PrepareReplayRequest<librbd::MockTestImageCtx> MockPrepareReplayRequest;
   typedef librbd::mirror::GetInfoRequest<librbd::MockTestImageCtx> MockGetMirrorInfoRequest;
@@ -355,10 +433,50 @@ public:
     ASSERT_EQ(0, open_image(m_local_io_ctx, m_image_name, &m_local_image_ctx));
   }
 
+  void expect_send(MockPrepareLocalImageRequest &mock_request,
+                   const std::string &local_image_id,
+                   const std::string &local_image_name,
+                   const std::string &tag_owner,
+                   int r) {
+    EXPECT_CALL(mock_request, send())
+      .WillOnce(Invoke([&mock_request, local_image_id, local_image_name,
+                        tag_owner, r]() {
+          if (r == 0) {
+            *mock_request.local_image_id = local_image_id;
+            *mock_request.local_image_name = local_image_name;
+            *mock_request.tag_owner = tag_owner;
+          }
+          mock_request.on_finish->complete(r);
+        }));
+  }
+
+  void expect_send(MockPrepareRemoteImageRequest& mock_request,
+                   ::journal::MockJournaler& mock_remote_journaler,
+                   const std::string& mirror_uuid, const std::string& image_id,
+                   cls::journal::ClientState client_state,
+                   const librbd::journal::MirrorPeerClientMeta& mirror_peer_client_meta,
+                   int r) {
+    EXPECT_CALL(mock_request, send())
+      .WillOnce(Invoke([&mock_request, &mock_remote_journaler, image_id,
+                        mirror_uuid, client_state, mirror_peer_client_meta,
+                        r]() {
+                  if (r >= 0) {
+                    *mock_request.remote_journaler = &mock_remote_journaler;
+                    *mock_request.client_state = client_state;
+                    *mock_request.client_meta = mirror_peer_client_meta;
+                  }
+
+                  *mock_request.remote_mirror_uuid = mirror_uuid;
+                  *mock_request.remote_image_id = image_id;
+                  mock_request.on_finish->complete(r);
+                }));
+  }
+
   void expect_open_image(MockOpenImageRequest &mock_open_image_request,
                          librados::IoCtx &io_ctx, const std::string &image_id,
                          librbd::MockTestImageCtx &mock_image_ctx, int r) {
-    EXPECT_CALL(mock_open_image_request, construct(IsSameIoCtx(&io_ctx), image_id));
+    EXPECT_CALL(mock_open_image_request,
+                construct(IsSameIoCtx(&io_ctx), image_id));
     EXPECT_CALL(mock_open_image_request, send())
       .WillOnce(Invoke([this, &mock_open_image_request, &mock_image_ctx, r]() {
           *mock_open_image_request.image_ctx = &mock_image_ctx;
@@ -449,38 +567,54 @@ public:
 
   MockBootstrapRequest *create_request(MockThreads* mock_threads,
                                        MockInstanceWatcher *mock_instance_watcher,
-                                       ::journal::MockJournaler &mock_journaler,
-                                       const std::string &local_image_id,
                                        const std::string &remote_image_id,
                                        const std::string &global_image_id,
                                        const std::string &local_mirror_uuid,
-                                       const std::string &remote_mirror_uuid,
-                                       cls::journal::ClientState *client_state,
-                                       librbd::journal::MirrorPeerClientMeta *mirror_peer_client_meta,
                                        Context *on_finish) {
-    return new MockBootstrapRequest(mock_threads, m_local_io_ctx,
+    return new MockBootstrapRequest(mock_threads,
+                                    m_local_io_ctx,
                                     m_remote_io_ctx,
                                     mock_instance_watcher,
-                                    &m_local_test_image_ctx,
-                                    local_image_id,
                                     remote_image_id,
                                     global_image_id,
                                     local_mirror_uuid,
-                                    remote_mirror_uuid,
-                                    &mock_journaler,
-                                    client_state, mirror_peer_client_meta,
-                                    on_finish, &m_do_resync);
+                                    nullptr, nullptr,
+                                    &m_local_test_image_ctx,
+                                    &m_local_image_id,
+                                    &m_remote_mirror_uuid,
+                                    &m_mock_remote_journaler,
+                                    &m_do_resync, on_finish);
   }
 
   librbd::ImageCtx *m_remote_image_ctx;
   librbd::ImageCtx *m_local_image_ctx = nullptr;
+
   librbd::MockTestImageCtx *m_local_test_image_ctx = nullptr;
+  std::string m_local_image_id;
+  std::string m_remote_mirror_uuid;
+  ::journal::MockJournaler *m_mock_remote_journaler = nullptr;
   bool m_do_resync = false;
 };
 
 TEST_F(TestMockImageReplayerBootstrapRequest, Success) {
   InSequence seq;
 
+  // prepare local image
+  MockPrepareLocalImageRequest mock_prepare_local_image_request;
+  expect_send(mock_prepare_local_image_request, m_local_image_ctx->id,
+              m_local_image_ctx->name, "remote mirror uuid", 0);
+
+  // prepare remote image
+  MockPrepareRemoteImageRequest mock_prepare_remote_image_request;
+  ::journal::MockJournaler mock_remote_journaler;
+  cls::journal::ClientState client_state = cls::journal::CLIENT_STATE_CONNECTED;
+  librbd::journal::MirrorPeerClientMeta mirror_peer_client_meta{
+    m_local_image_ctx->id};
+  mirror_peer_client_meta.state = librbd::journal::MIRROR_PEER_STATE_SYNCING;
+  expect_send(mock_prepare_remote_image_request, mock_remote_journaler,
+              "remote mirror uuid", m_remote_image_ctx->id, client_state,
+              mirror_peer_client_meta, 0);
+
   // open the remote image
   librbd::MockJournal mock_journal;
   librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx);
@@ -513,16 +647,9 @@ TEST_F(TestMockImageReplayerBootstrapRequest, Success) {
   C_SaferCond ctx;
   MockThreads mock_threads(m_threads);
   MockInstanceWatcher mock_instance_watcher;
-  ::journal::MockJournaler mock_remote_journaler;
-  cls::journal::ClientState client_state = cls::journal::CLIENT_STATE_CONNECTED;
-  librbd::journal::MirrorPeerClientMeta mirror_peer_client_meta{
-    mock_local_image_ctx.id};
-  mirror_peer_client_meta.state = librbd::journal::MIRROR_PEER_STATE_REPLAYING;
   MockBootstrapRequest *request = create_request(
-    &mock_threads, &mock_instance_watcher, mock_remote_journaler,
-    mock_local_image_ctx.id, mock_remote_image_ctx.id, "global image id",
-    "local mirror uuid", "remote mirror uuid", &client_state,
-    &mirror_peer_client_meta, &ctx);
+    &mock_threads, &mock_instance_watcher, mock_remote_image_ctx.id,
+    "global image id", "local mirror uuid", &ctx);
   request->send();
   ASSERT_EQ(0, ctx.wait());
 }
@@ -530,6 +657,22 @@ TEST_F(TestMockImageReplayerBootstrapRequest, Success) {
 TEST_F(TestMockImageReplayerBootstrapRequest, OpenLocalImageError) {
   InSequence seq;
 
+  // prepare local image
+  MockPrepareLocalImageRequest mock_prepare_local_image_request;
+  expect_send(mock_prepare_local_image_request, m_local_image_ctx->id,
+              m_local_image_ctx->name, "remote mirror uuid", 0);
+
+  // prepare remote image
+  MockPrepareRemoteImageRequest mock_prepare_remote_image_request;
+  ::journal::MockJournaler mock_remote_journaler;
+  cls::journal::ClientState client_state = cls::journal::CLIENT_STATE_CONNECTED;
+  librbd::journal::MirrorPeerClientMeta mirror_peer_client_meta{
+    m_local_image_ctx->id};
+  mirror_peer_client_meta.state = librbd::journal::MIRROR_PEER_STATE_SYNCING;
+  expect_send(mock_prepare_remote_image_request, mock_remote_journaler,
+              "remote mirror uuid", m_remote_image_ctx->id, client_state,
+              mirror_peer_client_meta, 0);
+
   // open the remote image
   librbd::MockJournal mock_journal;
   librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx);
@@ -559,16 +702,9 @@ TEST_F(TestMockImageReplayerBootstrapRequest, OpenLocalImageError) {
   C_SaferCond ctx;
   MockThreads mock_threads(m_threads);
   MockInstanceWatcher mock_instance_watcher;
-  ::journal::MockJournaler mock_remote_journaler;
-  cls::journal::ClientState client_state = cls::journal::CLIENT_STATE_CONNECTED;
-  librbd::journal::MirrorPeerClientMeta mirror_peer_client_meta{
-    mock_local_image_ctx.id};
-  mirror_peer_client_meta.state = librbd::journal::MIRROR_PEER_STATE_REPLAYING;
   MockBootstrapRequest *request = create_request(
-    &mock_threads, &mock_instance_watcher, mock_remote_journaler,
-    mock_local_image_ctx.id, mock_remote_image_ctx.id, "global image id",
-    "local mirror uuid", "remote mirror uuid", &client_state,
-    &mirror_peer_client_meta, &ctx);
+    &mock_threads, &mock_instance_watcher, mock_remote_image_ctx.id,
+    "global image id", "local mirror uuid", &ctx);
   request->send();
   ASSERT_EQ(-EINVAL, ctx.wait());
 }
@@ -576,6 +712,22 @@ TEST_F(TestMockImageReplayerBootstrapRequest, OpenLocalImageError) {
 TEST_F(TestMockImageReplayerBootstrapRequest, OpenLocalImageDNE) {
   InSequence seq;
 
+  // prepare local image
+  MockPrepareLocalImageRequest mock_prepare_local_image_request;
+  expect_send(mock_prepare_local_image_request, m_local_image_ctx->id,
+              m_local_image_ctx->name, "remote mirror uuid", 0);
+
+  // prepare remote image
+  MockPrepareRemoteImageRequest mock_prepare_remote_image_request;
+  ::journal::MockJournaler mock_remote_journaler;
+  cls::journal::ClientState client_state = cls::journal::CLIENT_STATE_CONNECTED;
+  librbd::journal::MirrorPeerClientMeta mirror_peer_client_meta{
+    m_local_image_ctx->id};
+  mirror_peer_client_meta.state = librbd::journal::MIRROR_PEER_STATE_SYNCING;
+  expect_send(mock_prepare_remote_image_request, mock_remote_journaler,
+              "remote mirror uuid", m_remote_image_ctx->id, client_state,
+              mirror_peer_client_meta, 0);
+
   // open the remote image
   librbd::MockJournal mock_journal;
   librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx);
@@ -618,16 +770,9 @@ TEST_F(TestMockImageReplayerBootstrapRequest, OpenLocalImageDNE) {
   C_SaferCond ctx;
   MockThreads mock_threads(m_threads);
   MockInstanceWatcher mock_instance_watcher;
-  ::journal::MockJournaler mock_remote_journaler;
-  cls::journal::ClientState client_state = cls::journal::CLIENT_STATE_CONNECTED;
-  librbd::journal::MirrorPeerClientMeta mirror_peer_client_meta{
-    mock_local_image_ctx.id};
-  mirror_peer_client_meta.state = librbd::journal::MIRROR_PEER_STATE_REPLAYING;
   MockBootstrapRequest *request = create_request(
-    &mock_threads, &mock_instance_watcher, mock_remote_journaler,
-    mock_local_image_ctx.id, mock_remote_image_ctx.id, "global image id",
-    "local mirror uuid", "remote mirror uuid", &client_state,
-    &mirror_peer_client_meta, &ctx);
+    &mock_threads, &mock_instance_watcher, mock_remote_image_ctx.id,
+    "global image id", "local mirror uuid", &ctx);
   request->send();
   ASSERT_EQ(0, ctx.wait());
 }
@@ -635,6 +780,22 @@ TEST_F(TestMockImageReplayerBootstrapRequest, OpenLocalImageDNE) {
 TEST_F(TestMockImageReplayerBootstrapRequest, OpenLocalImagePrimary) {
   InSequence seq;
 
+  // prepare local image
+  MockPrepareLocalImageRequest mock_prepare_local_image_request;
+  expect_send(mock_prepare_local_image_request, m_local_image_ctx->id,
+              m_local_image_ctx->name, "remote mirror uuid", 0);
+
+  // prepare remote image
+  MockPrepareRemoteImageRequest mock_prepare_remote_image_request;
+  ::journal::MockJournaler mock_remote_journaler;
+  cls::journal::ClientState client_state = cls::journal::CLIENT_STATE_CONNECTED;
+  librbd::journal::MirrorPeerClientMeta mirror_peer_client_meta{
+    m_local_image_ctx->id};
+  mirror_peer_client_meta.state = librbd::journal::MIRROR_PEER_STATE_SYNCING;
+  expect_send(mock_prepare_remote_image_request, mock_remote_journaler,
+              "remote mirror uuid", m_remote_image_ctx->id, client_state,
+              mirror_peer_client_meta, 0);
+
   // open the remote image
   librbd::MockJournal mock_journal;
   librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx);
@@ -664,16 +825,9 @@ TEST_F(TestMockImageReplayerBootstrapRequest, OpenLocalImagePrimary) {
   C_SaferCond ctx;
   MockThreads mock_threads(m_threads);
   MockInstanceWatcher mock_instance_watcher;
-  ::journal::MockJournaler mock_remote_journaler;
-  cls::journal::ClientState client_state = cls::journal::CLIENT_STATE_CONNECTED;
-  librbd::journal::MirrorPeerClientMeta mirror_peer_client_meta{
-    mock_local_image_ctx.id};
-  mirror_peer_client_meta.state = librbd::journal::MIRROR_PEER_STATE_REPLAYING;
   MockBootstrapRequest *request = create_request(
-    &mock_threads, &mock_instance_watcher, mock_remote_journaler,
-    mock_local_image_ctx.id, mock_remote_image_ctx.id, "global image id",
-    "local mirror uuid", "remote mirror uuid", &client_state,
-    &mirror_peer_client_meta, &ctx);
+    &mock_threads, &mock_instance_watcher, mock_remote_image_ctx.id,
+    "global image id", "local mirror uuid", &ctx);
   request->send();
   ASSERT_EQ(-EREMOTEIO, ctx.wait());
 }
@@ -681,6 +835,20 @@ TEST_F(TestMockImageReplayerBootstrapRequest, OpenLocalImagePrimary) {
 TEST_F(TestMockImageReplayerBootstrapRequest, CreateLocalImageError) {
   InSequence seq;
 
+  // prepare local image
+  MockPrepareLocalImageRequest mock_prepare_local_image_request;
+  expect_send(mock_prepare_local_image_request, "", "", "", 0);
+
+  // prepare remote image
+  MockPrepareRemoteImageRequest mock_prepare_remote_image_request;
+  ::journal::MockJournaler mock_remote_journaler;
+  cls::journal::ClientState client_state = cls::journal::CLIENT_STATE_CONNECTED;
+  librbd::journal::MirrorPeerClientMeta mirror_peer_client_meta;
+  mirror_peer_client_meta.state = librbd::journal::MIRROR_PEER_STATE_SYNCING;
+  expect_send(mock_prepare_remote_image_request, mock_remote_journaler,
+              "remote mirror uuid", m_remote_image_ctx->id, client_state,
+              mirror_peer_client_meta, 0);
+
   // open the remote image
   librbd::MockJournal mock_journal;
   librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx);
@@ -707,15 +875,9 @@ TEST_F(TestMockImageReplayerBootstrapRequest, CreateLocalImageError) {
   C_SaferCond ctx;
   MockThreads mock_threads(m_threads);
   MockInstanceWatcher mock_instance_watcher;
-  ::journal::MockJournaler mock_remote_journaler;
-  cls::journal::ClientState client_state = cls::journal::CLIENT_STATE_CONNECTED;
-  librbd::journal::MirrorPeerClientMeta mirror_peer_client_meta;
-  mirror_peer_client_meta.state = librbd::journal::MIRROR_PEER_STATE_REPLAYING;
   MockBootstrapRequest *request = create_request(
-    &mock_threads, &mock_instance_watcher, mock_remote_journaler, "",
-    mock_remote_image_ctx.id, "global image id",
-    "local mirror uuid", "remote mirror uuid", &client_state,
-    &mirror_peer_client_meta, &ctx);
+    &mock_threads, &mock_instance_watcher, mock_remote_image_ctx.id,
+    "global image id", "local mirror uuid", &ctx);
   request->send();
   ASSERT_EQ(-EINVAL, ctx.wait());
 }
@@ -723,6 +885,22 @@ TEST_F(TestMockImageReplayerBootstrapRequest, CreateLocalImageError) {
 TEST_F(TestMockImageReplayerBootstrapRequest, PrepareReplayError) {
   InSequence seq;
 
+  // prepare local image
+  MockPrepareLocalImageRequest mock_prepare_local_image_request;
+  expect_send(mock_prepare_local_image_request, m_local_image_ctx->id,
+              m_local_image_ctx->name, "remote mirror uuid", 0);
+
+  // prepare remote image
+  MockPrepareRemoteImageRequest mock_prepare_remote_image_request;
+  ::journal::MockJournaler mock_remote_journaler;
+  cls::journal::ClientState client_state = cls::journal::CLIENT_STATE_CONNECTED;
+  librbd::journal::MirrorPeerClientMeta mirror_peer_client_meta{
+    m_local_image_ctx->id};
+  mirror_peer_client_meta.state = librbd::journal::MIRROR_PEER_STATE_SYNCING;
+  expect_send(mock_prepare_remote_image_request, mock_remote_journaler,
+              "remote mirror uuid", m_remote_image_ctx->id, client_state,
+              mirror_peer_client_meta, 0);
+
   // open the remote image
   librbd::MockJournal mock_journal;
   librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx);
@@ -758,16 +936,9 @@ TEST_F(TestMockImageReplayerBootstrapRequest, PrepareReplayError) {
   C_SaferCond ctx;
   MockThreads mock_threads(m_threads);
   MockInstanceWatcher mock_instance_watcher;
-  ::journal::MockJournaler mock_remote_journaler;
-  cls::journal::ClientState client_state = cls::journal::CLIENT_STATE_CONNECTED;
-  librbd::journal::MirrorPeerClientMeta mirror_peer_client_meta{
-    mock_local_image_ctx.id};
-  mirror_peer_client_meta.state = librbd::journal::MIRROR_PEER_STATE_REPLAYING;
   MockBootstrapRequest *request = create_request(
-    &mock_threads, &mock_instance_watcher, mock_remote_journaler,
-    mock_local_image_ctx.id, mock_remote_image_ctx.id, "global image id",
-    "local mirror uuid", "remote mirror uuid", &client_state,
-    &mirror_peer_client_meta, &ctx);
+    &mock_threads, &mock_instance_watcher, mock_remote_image_ctx.id,
+    "global image id", "local mirror uuid", &ctx);
   request->send();
   ASSERT_EQ(-EINVAL, ctx.wait());
 }
@@ -775,6 +946,22 @@ TEST_F(TestMockImageReplayerBootstrapRequest, PrepareReplayError) {
 TEST_F(TestMockImageReplayerBootstrapRequest, PrepareReplayResyncRequested) {
   InSequence seq;
 
+  // prepare local image
+  MockPrepareLocalImageRequest mock_prepare_local_image_request;
+  expect_send(mock_prepare_local_image_request, m_local_image_ctx->id,
+              m_local_image_ctx->name, "remote mirror uuid", 0);
+
+  // prepare remote image
+  MockPrepareRemoteImageRequest mock_prepare_remote_image_request;
+  ::journal::MockJournaler mock_remote_journaler;
+  cls::journal::ClientState client_state = cls::journal::CLIENT_STATE_CONNECTED;
+  librbd::journal::MirrorPeerClientMeta mirror_peer_client_meta{
+    m_local_image_ctx->id};
+  mirror_peer_client_meta.state = librbd::journal::MIRROR_PEER_STATE_SYNCING;
+  expect_send(mock_prepare_remote_image_request, mock_remote_journaler,
+              "remote mirror uuid", m_remote_image_ctx->id, client_state,
+              mirror_peer_client_meta, 0);
+
   // open the remote image
   librbd::MockJournal mock_journal;
   librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx);
@@ -807,16 +994,9 @@ TEST_F(TestMockImageReplayerBootstrapRequest, PrepareReplayResyncRequested) {
   C_SaferCond ctx;
   MockThreads mock_threads(m_threads);
   MockInstanceWatcher mock_instance_watcher;
-  ::journal::MockJournaler mock_remote_journaler;
-  cls::journal::ClientState client_state = cls::journal::CLIENT_STATE_CONNECTED;
-  librbd::journal::MirrorPeerClientMeta mirror_peer_client_meta{
-    mock_local_image_ctx.id};
-  mirror_peer_client_meta.state = librbd::journal::MIRROR_PEER_STATE_REPLAYING;
   MockBootstrapRequest *request = create_request(
-    &mock_threads, &mock_instance_watcher, mock_remote_journaler,
-    mock_local_image_ctx.id, mock_remote_image_ctx.id, "global image id",
-    "local mirror uuid", "remote mirror uuid", &client_state,
-    &mirror_peer_client_meta, &ctx);
+    &mock_threads, &mock_instance_watcher, mock_remote_image_ctx.id,
+    "global image id", "local mirror uuid", &ctx);
   request->send();
   ASSERT_EQ(0, ctx.wait());
   ASSERT_TRUE(m_do_resync);
@@ -825,6 +1005,22 @@ TEST_F(TestMockImageReplayerBootstrapRequest, PrepareReplayResyncRequested) {
 TEST_F(TestMockImageReplayerBootstrapRequest, PrepareReplaySyncing) {
   InSequence seq;
 
+  // prepare local image
+  MockPrepareLocalImageRequest mock_prepare_local_image_request;
+  expect_send(mock_prepare_local_image_request, m_local_image_ctx->id,
+              m_local_image_ctx->name, "remote mirror uuid", 0);
+
+  // prepare remote image
+  MockPrepareRemoteImageRequest mock_prepare_remote_image_request;
+  ::journal::MockJournaler mock_remote_journaler;
+  cls::journal::ClientState client_state = cls::journal::CLIENT_STATE_CONNECTED;
+  librbd::journal::MirrorPeerClientMeta mirror_peer_client_meta{
+    m_local_image_ctx->id};
+  mirror_peer_client_meta.state = librbd::journal::MIRROR_PEER_STATE_SYNCING;
+  expect_send(mock_prepare_remote_image_request, mock_remote_journaler,
+              "remote mirror uuid", m_remote_image_ctx->id, client_state,
+              mirror_peer_client_meta, 0);
+
   // open the remote image
   librbd::MockJournal mock_journal;
   librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx);
@@ -861,16 +1057,9 @@ TEST_F(TestMockImageReplayerBootstrapRequest, PrepareReplaySyncing) {
   C_SaferCond ctx;
   MockThreads mock_threads(m_threads);
   MockInstanceWatcher mock_instance_watcher;
-  ::journal::MockJournaler mock_remote_journaler;
-  cls::journal::ClientState client_state = cls::journal::CLIENT_STATE_CONNECTED;
-  librbd::journal::MirrorPeerClientMeta mirror_peer_client_meta{
-    mock_local_image_ctx.id};
-  mirror_peer_client_meta.state = librbd::journal::MIRROR_PEER_STATE_REPLAYING;
   MockBootstrapRequest *request = create_request(
-    &mock_threads, &mock_instance_watcher, mock_remote_journaler,
-    mock_local_image_ctx.id, mock_remote_image_ctx.id, "global image id",
-    "local mirror uuid", "remote mirror uuid", &client_state,
-    &mirror_peer_client_meta, &ctx);
+    &mock_threads, &mock_instance_watcher, mock_remote_image_ctx.id,
+    "global image id", "local mirror uuid", &ctx);
   request->send();
   ASSERT_EQ(0, ctx.wait());
 }
@@ -878,6 +1067,22 @@ TEST_F(TestMockImageReplayerBootstrapRequest, PrepareReplaySyncing) {
 TEST_F(TestMockImageReplayerBootstrapRequest, PrepareReplayDisconnected) {
   InSequence seq;
 
+  // prepare local image
+  MockPrepareLocalImageRequest mock_prepare_local_image_request;
+  expect_send(mock_prepare_local_image_request, m_local_image_ctx->id,
+              m_local_image_ctx->name, "remote mirror uuid", 0);
+
+  // prepare remote image
+  MockPrepareRemoteImageRequest mock_prepare_remote_image_request;
+  ::journal::MockJournaler mock_remote_journaler;
+  cls::journal::ClientState client_state = cls::journal::CLIENT_STATE_CONNECTED;
+  librbd::journal::MirrorPeerClientMeta mirror_peer_client_meta{
+    m_local_image_ctx->id};
+  mirror_peer_client_meta.state = librbd::journal::MIRROR_PEER_STATE_SYNCING;
+  expect_send(mock_prepare_remote_image_request, mock_remote_journaler,
+              "remote mirror uuid", m_remote_image_ctx->id, client_state,
+              mirror_peer_client_meta, 0);
+
   // open the remote image
   librbd::MockJournal mock_journal;
   librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx);
@@ -910,17 +1115,9 @@ TEST_F(TestMockImageReplayerBootstrapRequest, PrepareReplayDisconnected) {
   C_SaferCond ctx;
   MockThreads mock_threads(m_threads);
   MockInstanceWatcher mock_instance_watcher;
-  ::journal::MockJournaler mock_remote_journaler;
-  cls::journal::ClientState client_state =
-    cls::journal::CLIENT_STATE_DISCONNECTED;
-  librbd::journal::MirrorPeerClientMeta mirror_peer_client_meta{
-    mock_local_image_ctx.id};
-  mirror_peer_client_meta.state = librbd::journal::MIRROR_PEER_STATE_REPLAYING;
   MockBootstrapRequest *request = create_request(
-    &mock_threads, &mock_instance_watcher, mock_remote_journaler,
-    mock_local_image_ctx.id, mock_remote_image_ctx.id, "global image id",
-    "local mirror uuid", "remote mirror uuid", &client_state,
-    &mirror_peer_client_meta, &ctx);
+    &mock_threads, &mock_instance_watcher, mock_remote_image_ctx.id,
+    "global image id", "local mirror uuid", &ctx);
   request->send();
   ASSERT_EQ(0, ctx.wait());
 }
@@ -928,6 +1125,22 @@ TEST_F(TestMockImageReplayerBootstrapRequest, PrepareReplayDisconnected) {
 TEST_F(TestMockImageReplayerBootstrapRequest, ImageSyncError) {
   InSequence seq;
 
+  // prepare local image
+  MockPrepareLocalImageRequest mock_prepare_local_image_request;
+  expect_send(mock_prepare_local_image_request, m_local_image_ctx->id,
+              m_local_image_ctx->name, "remote mirror uuid", 0);
+
+  // prepare remote image
+  MockPrepareRemoteImageRequest mock_prepare_remote_image_request;
+  ::journal::MockJournaler mock_remote_journaler;
+  cls::journal::ClientState client_state = cls::journal::CLIENT_STATE_CONNECTED;
+  librbd::journal::MirrorPeerClientMeta mirror_peer_client_meta{
+    m_local_image_ctx->id};
+  mirror_peer_client_meta.state = librbd::journal::MIRROR_PEER_STATE_SYNCING;
+  expect_send(mock_prepare_remote_image_request, mock_remote_journaler,
+              "remote mirror uuid", m_remote_image_ctx->id, client_state,
+              mirror_peer_client_meta, 0);
+
   // open the remote image
   librbd::MockJournal mock_journal;
   librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx);
@@ -964,16 +1177,9 @@ TEST_F(TestMockImageReplayerBootstrapRequest, ImageSyncError) {
   C_SaferCond ctx;
   MockThreads mock_threads(m_threads);
   MockInstanceWatcher mock_instance_watcher;
-  ::journal::MockJournaler mock_remote_journaler;
-  cls::journal::ClientState client_state = cls::journal::CLIENT_STATE_CONNECTED;
-  librbd::journal::MirrorPeerClientMeta mirror_peer_client_meta{
-    mock_local_image_ctx.id};
-  mirror_peer_client_meta.state = librbd::journal::MIRROR_PEER_STATE_REPLAYING;
   MockBootstrapRequest *request = create_request(
-    &mock_threads, &mock_instance_watcher, mock_remote_journaler,
-    mock_local_image_ctx.id, mock_remote_image_ctx.id, "global image id",
-    "local mirror uuid", "remote mirror uuid", &client_state,
-    &mirror_peer_client_meta, &ctx);
+    &mock_threads, &mock_instance_watcher, mock_remote_image_ctx.id,
+    "global image id", "local mirror uuid", &ctx);
   request->send();
   ASSERT_EQ(-EINVAL, ctx.wait());
 }
@@ -981,6 +1187,22 @@ TEST_F(TestMockImageReplayerBootstrapRequest, ImageSyncError) {
 TEST_F(TestMockImageReplayerBootstrapRequest, ImageSyncCanceled) {
   InSequence seq;
 
+  // prepare local image
+  MockPrepareLocalImageRequest mock_prepare_local_image_request;
+  expect_send(mock_prepare_local_image_request, m_local_image_ctx->id,
+              m_local_image_ctx->name, "remote mirror uuid", 0);
+
+  // prepare remote image
+  MockPrepareRemoteImageRequest mock_prepare_remote_image_request;
+  ::journal::MockJournaler mock_remote_journaler;
+  cls::journal::ClientState client_state = cls::journal::CLIENT_STATE_CONNECTED;
+  librbd::journal::MirrorPeerClientMeta mirror_peer_client_meta{
+    m_local_image_ctx->id};
+  mirror_peer_client_meta.state = librbd::journal::MIRROR_PEER_STATE_SYNCING;
+  expect_send(mock_prepare_remote_image_request, mock_remote_journaler,
+              "remote mirror uuid", m_remote_image_ctx->id, client_state,
+              mirror_peer_client_meta, 0);
+
   // open the remote image
   librbd::MockJournal mock_journal;
   librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx);
@@ -1013,16 +1235,9 @@ TEST_F(TestMockImageReplayerBootstrapRequest, ImageSyncCanceled) {
   C_SaferCond ctx;
   MockThreads mock_threads(m_threads);
   MockInstanceWatcher mock_instance_watcher;
-  ::journal::MockJournaler mock_remote_journaler;
-  cls::journal::ClientState client_state = cls::journal::CLIENT_STATE_CONNECTED;
-  librbd::journal::MirrorPeerClientMeta mirror_peer_client_meta{
-    mock_local_image_ctx.id};
-  mirror_peer_client_meta.state = librbd::journal::MIRROR_PEER_STATE_REPLAYING;
   MockBootstrapRequest *request = create_request(
-    &mock_threads, &mock_instance_watcher, mock_remote_journaler,
-    mock_local_image_ctx.id, mock_remote_image_ctx.id, "global image id",
-    "local mirror uuid", "remote mirror uuid", &client_state,
-    &mirror_peer_client_meta, &ctx);
+    &mock_threads, &mock_instance_watcher, mock_remote_image_ctx.id,
+    "global image id", "local mirror uuid", &ctx);
   request->cancel();
   request->send();
   ASSERT_EQ(-ECANCELED, ctx.wait());
@@ -1031,6 +1246,22 @@ TEST_F(TestMockImageReplayerBootstrapRequest, ImageSyncCanceled) {
 TEST_F(TestMockImageReplayerBootstrapRequest, CloseLocalImageError) {
   InSequence seq;
 
+  // prepare local image
+  MockPrepareLocalImageRequest mock_prepare_local_image_request;
+  expect_send(mock_prepare_local_image_request, m_local_image_ctx->id,
+              m_local_image_ctx->name, "remote mirror uuid", 0);
+
+  // prepare remote image
+  MockPrepareRemoteImageRequest mock_prepare_remote_image_request;
+  ::journal::MockJournaler mock_remote_journaler;
+  cls::journal::ClientState client_state = cls::journal::CLIENT_STATE_CONNECTED;
+  librbd::journal::MirrorPeerClientMeta mirror_peer_client_meta{
+    m_local_image_ctx->id};
+  mirror_peer_client_meta.state = librbd::journal::MIRROR_PEER_STATE_SYNCING;
+  expect_send(mock_prepare_remote_image_request, mock_remote_journaler,
+              "remote mirror uuid", m_remote_image_ctx->id, client_state,
+              mirror_peer_client_meta, 0);
+
   // open the remote image
   librbd::MockJournal mock_journal;
   librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx);
@@ -1066,16 +1297,9 @@ TEST_F(TestMockImageReplayerBootstrapRequest, CloseLocalImageError) {
   C_SaferCond ctx;
   MockThreads mock_threads(m_threads);
   MockInstanceWatcher mock_instance_watcher;
-  ::journal::MockJournaler mock_remote_journaler;
-  cls::journal::ClientState client_state = cls::journal::CLIENT_STATE_CONNECTED;
-  librbd::journal::MirrorPeerClientMeta mirror_peer_client_meta{
-    mock_local_image_ctx.id};
-  mirror_peer_client_meta.state = librbd::journal::MIRROR_PEER_STATE_REPLAYING;
   MockBootstrapRequest *request = create_request(
-    &mock_threads, &mock_instance_watcher, mock_remote_journaler,
-    mock_local_image_ctx.id, mock_remote_image_ctx.id, "global image id",
-    "local mirror uuid", "remote mirror uuid", &client_state,
-    &mirror_peer_client_meta, &ctx);
+    &mock_threads, &mock_instance_watcher, mock_remote_image_ctx.id,
+    "global image id", "local mirror uuid", &ctx);
   request->send();
   ASSERT_EQ(-EREMOTEIO, ctx.wait());
 }
@@ -1083,6 +1307,22 @@ TEST_F(TestMockImageReplayerBootstrapRequest, CloseLocalImageError) {
 TEST_F(TestMockImageReplayerBootstrapRequest, CloseRemoteImageError) {
   InSequence seq;
 
+  // prepare local image
+  MockPrepareLocalImageRequest mock_prepare_local_image_request;
+  expect_send(mock_prepare_local_image_request, m_local_image_ctx->id,
+              m_local_image_ctx->name, "remote mirror uuid", 0);
+
+  // prepare remote image
+  MockPrepareRemoteImageRequest mock_prepare_remote_image_request;
+  ::journal::MockJournaler mock_remote_journaler;
+  cls::journal::ClientState client_state = cls::journal::CLIENT_STATE_CONNECTED;
+  librbd::journal::MirrorPeerClientMeta mirror_peer_client_meta{
+    m_local_image_ctx->id};
+  mirror_peer_client_meta.state = librbd::journal::MIRROR_PEER_STATE_SYNCING;
+  expect_send(mock_prepare_remote_image_request, mock_remote_journaler,
+              "remote mirror uuid", m_remote_image_ctx->id, client_state,
+              mirror_peer_client_meta, 0);
+
   // open the remote image
   librbd::MockJournal mock_journal;
   librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx);
@@ -1114,16 +1354,9 @@ TEST_F(TestMockImageReplayerBootstrapRequest, CloseRemoteImageError) {
   C_SaferCond ctx;
   MockThreads mock_threads(m_threads);
   MockInstanceWatcher mock_instance_watcher;
-  ::journal::MockJournaler mock_remote_journaler;
-  cls::journal::ClientState client_state = cls::journal::CLIENT_STATE_CONNECTED;
-  librbd::journal::MirrorPeerClientMeta mirror_peer_client_meta{
-    mock_local_image_ctx.id};
-  mirror_peer_client_meta.state = librbd::journal::MIRROR_PEER_STATE_REPLAYING;
   MockBootstrapRequest *request = create_request(
-    &mock_threads, &mock_instance_watcher, mock_remote_journaler,
-    mock_local_image_ctx.id, mock_remote_image_ctx.id, "global image id",
-    "local mirror uuid", "remote mirror uuid", &client_state,
-    &mirror_peer_client_meta, &ctx);
+    &mock_threads, &mock_instance_watcher, mock_remote_image_ctx.id,
+    "global image id", "local mirror uuid", &ctx);
   request->send();
   ASSERT_EQ(0, ctx.wait());
 }
diff --git a/src/test/rbd_mirror/test_mock_ImageReplayer.cc b/src/test/rbd_mirror/test_mock_ImageReplayer.cc
index 76a8eb39319..01bf2e499c2 100644
--- a/src/test/rbd_mirror/test_mock_ImageReplayer.cc
+++ b/src/test/rbd_mirror/test_mock_ImageReplayer.cc
@@ -11,8 +11,6 @@
 #include "tools/rbd_mirror/Threads.h"
 #include "tools/rbd_mirror/image_replayer/BootstrapRequest.h"
 #include "tools/rbd_mirror/image_replayer/CloseImageRequest.h"
-#include "tools/rbd_mirror/image_replayer/PrepareLocalImageRequest.h"
-#include "tools/rbd_mirror/image_replayer/PrepareRemoteImageRequest.h"
 #include "tools/rbd_mirror/image_replayer/Replayer.h"
 #include "tools/rbd_mirror/image_replayer/ReplayerListener.h"
 #include "tools/rbd_mirror/image_replayer/Utils.h"
@@ -42,8 +40,6 @@ struct TypeTraits<MockTestImageCtx> {
   typedef ::journal::MockJournalerProxy Journaler;
 };
 
-struct MirrorPeerClientMeta;
-
 } // namespace journal
 } // namespace librbd
 
@@ -105,100 +101,33 @@ class InstanceWatcher<librbd::MockTestImageCtx> {
 namespace image_replayer {
 
 template<>
-struct PrepareLocalImageRequest<librbd::MockTestImageCtx> {
-  static PrepareLocalImageRequest* s_instance;
-  std::string *local_image_id = nullptr;
-  std::string *local_image_name = nullptr;
-  std::string *tag_owner = nullptr;
-  Context *on_finish = nullptr;
-
-  static PrepareLocalImageRequest* create(librados::IoCtx &,
-                                          const std::string &global_image_id,
-                                          std::string *local_image_id,
-                                          std::string *local_image_name,
-                                          std::string *tag_owner,
-                                          MockContextWQ *work_queue,
-                                          Context *on_finish) {
-    ceph_assert(s_instance != nullptr);
-    s_instance->local_image_id = local_image_id;
-    s_instance->local_image_name = local_image_name;
-    s_instance->tag_owner = tag_owner;
-    s_instance->on_finish = on_finish;
-    return s_instance;
-  }
-
-  PrepareLocalImageRequest() {
-    s_instance = this;
-  }
-
-  MOCK_METHOD0(send, void());
-};
-
-template<>
-struct PrepareRemoteImageRequest<librbd::MockTestImageCtx> {
-  static PrepareRemoteImageRequest* s_instance;
-  std::string *remote_mirror_uuid = nullptr;
-  std::string *remote_image_id = nullptr;
-  cls::journal::ClientState *client_state;
-  ::journal::MockJournalerProxy **remote_journaler = nullptr;
-  librbd::journal::MirrorPeerClientMeta *client_meta = nullptr;
-  Context *on_finish = nullptr;
-
-  static PrepareRemoteImageRequest* create(Threads<librbd::MockTestImageCtx> *threads,
-                                           librados::IoCtx &,
-                                           const std::string &global_image_id,
-                                           const std::string &local_mirror_uuid,
-                                           const std::string &local_image_id,
-                                           const ::journal::Settings &settings,
-                                           ::journal::CacheManagerHandler *cache_manager_handler,
-                                           std::string *remote_mirror_uuid,
-                                           std::string *remote_image_id,
-                                           ::journal::MockJournalerProxy **remote_journaler,
-                                           cls::journal::ClientState *client_state,
-                                           librbd::journal::MirrorPeerClientMeta *client_meta,
-                                           Context *on_finish) {
-    ceph_assert(s_instance != nullptr);
-    s_instance->remote_mirror_uuid = remote_mirror_uuid;
-    s_instance->remote_image_id = remote_image_id;
-    s_instance->remote_journaler = remote_journaler;
-    s_instance->client_state = client_state;
-    s_instance->client_meta = client_meta;
-    s_instance->on_finish = on_finish;
-    return s_instance;
-  }
-
-  PrepareRemoteImageRequest() {
-    s_instance = this;
-  }
-
-  MOCK_METHOD0(send, void());
-};
-
-template<>
 struct BootstrapRequest<librbd::MockTestImageCtx> {
   static BootstrapRequest* s_instance;
   librbd::MockTestImageCtx **image_ctx = nullptr;
-  Context *on_finish = nullptr;
+  std::string* local_image_id = nullptr;
   bool *do_resync = nullptr;
+  Context *on_finish = nullptr;
 
   static BootstrapRequest* create(
       Threads<librbd::MockTestImageCtx>* threads,
-      librados::IoCtx &local_io_ctx, librados::IoCtx &remote_io_ctx,
+      librados::IoCtx &local_io_ctx,
+      librados::IoCtx &remote_io_ctx,
       rbd::mirror::InstanceWatcher<librbd::MockTestImageCtx> *instance_watcher,
-      librbd::MockTestImageCtx **local_image_ctx,
-      const std::string &local_image_name, const std::string &remote_image_id,
+      const std::string &remote_image_id,
       const std::string &global_image_id,
       const std::string &local_mirror_uuid,
-      const std::string &remote_mirror_uuid,
-      ::journal::MockJournalerProxy *journaler,
-      cls::journal::ClientState *client_state,
-      librbd::journal::MirrorPeerClientMeta *client_meta,
-      Context *on_finish, bool *do_resync,
-      rbd::mirror::ProgressContext *progress_ctx = nullptr) {
+      ::journal::CacheManagerHandler *cache_manager_handler,
+      rbd::mirror::ProgressContext *progress_ctx,
+      librbd::MockTestImageCtx **local_image_ctx,
+      std::string* local_image_id,
+      std::string* remote_mirror_uuid,
+      ::journal::MockJournalerProxy** remote_journaler,
+      bool *do_resync, Context *on_finish) {
     ceph_assert(s_instance != nullptr);
     s_instance->image_ctx = local_image_ctx;
-    s_instance->on_finish = on_finish;
+    s_instance->local_image_id = local_image_id;
     s_instance->do_resync = do_resync;
+    s_instance->on_finish = on_finish;
     return s_instance;
   }
 
@@ -218,6 +147,10 @@ struct BootstrapRequest<librbd::MockTestImageCtx> {
   void get() {
   }
 
+  std::string get_local_image_name() const {
+    return "local image name";
+  }
+
   inline bool is_syncing() const {
     return false;
   }
@@ -255,8 +188,6 @@ struct CloseImageRequest<librbd::MockTestImageCtx> {
 
 BootstrapRequest<librbd::MockTestImageCtx>* BootstrapRequest<librbd::MockTestImageCtx>::s_instance = nullptr;
 CloseImageRequest<librbd::MockTestImageCtx>* CloseImageRequest<librbd::MockTestImageCtx>::s_instance = nullptr;
-PrepareLocalImageRequest<librbd::MockTestImageCtx>* PrepareLocalImageRequest<librbd::MockTestImageCtx>::s_instance = nullptr;
-PrepareRemoteImageRequest<librbd::MockTestImageCtx>* PrepareRemoteImageRequest<librbd::MockTestImageCtx>::s_instance = nullptr;
 
 namespace journal {
 
@@ -328,8 +259,6 @@ public:
   typedef MirrorStatusUpdater<librbd::MockTestImageCtx> MockMirrorStatusUpdater;
   typedef image_replayer::BootstrapRequest<librbd::MockTestImageCtx> MockBootstrapRequest;
   typedef image_replayer::CloseImageRequest<librbd::MockTestImageCtx> MockCloseImageRequest;
-  typedef image_replayer::PrepareLocalImageRequest<librbd::MockTestImageCtx> MockPrepareLocalImageRequest;
-  typedef image_replayer::PrepareRemoteImageRequest<librbd::MockTestImageCtx> MockPrepareRemoteImageRequest;
   typedef image_replayer::journal::Replayer<librbd::MockTestImageCtx> MockJournalReplayer;
   typedef ImageReplayer<librbd::MockTestImageCtx> MockImageReplayer;
   typedef InstanceWatcher<librbd::MockTestImageCtx> MockInstanceWatcher;
@@ -391,37 +320,6 @@ public:
     return bl;
   }
 
-  void expect_send(MockPrepareLocalImageRequest &mock_request,
-                   const std::string &local_image_id,
-                   const std::string &local_image_name,
-                   const std::string &tag_owner,
-                   int r) {
-    EXPECT_CALL(mock_request, send())
-      .WillOnce(Invoke([&mock_request, local_image_id, local_image_name, tag_owner, r]() {
-          if (r == 0) {
-            *mock_request.local_image_id = local_image_id;
-            *mock_request.local_image_name = local_image_name;
-            *mock_request.tag_owner = tag_owner;
-          }
-          mock_request.on_finish->complete(r);
-        }));
-  }
-
-  void expect_send(MockPrepareRemoteImageRequest& mock_request,
-                   const std::string& mirror_uuid, const std::string& image_id,
-                   int r) {
-    EXPECT_CALL(mock_request, send())
-      .WillOnce(Invoke([&mock_request, image_id, mirror_uuid, r]() {
-                  if (r >= 0) {
-                    *mock_request.remote_journaler = new ::journal::MockJournalerProxy();
-                  }
-
-                  *mock_request.remote_mirror_uuid = mirror_uuid;
-                  *mock_request.remote_image_id = image_id;
-                  mock_request.on_finish->complete(r);
-                }));
-  }
-
   void expect_send(MockBootstrapRequest &mock_bootstrap_request,
                    librbd::MockTestImageCtx &mock_local_image_ctx,
                    bool do_resync, int r) {
@@ -431,6 +329,8 @@ public:
             if (r == 0) {
               *mock_bootstrap_request.image_ctx = &mock_local_image_ctx;
               *mock_bootstrap_request.do_resync = do_resync;
+            } else if (r == -ENOLINK) {
+              *mock_bootstrap_request.local_image_id = mock_local_image_ctx.id;
             }
             mock_bootstrap_request.on_finish->complete(r);
           }));
@@ -521,8 +421,6 @@ TEST_F(TestMockImageReplayer, StartStop) {
   expect_add_event_after_repeatedly(mock_threads);
 
   MockImageDeleter mock_image_deleter;
-  MockPrepareLocalImageRequest mock_prepare_local_image_request;
-  MockPrepareRemoteImageRequest mock_prepare_remote_image_request;
   MockBootstrapRequest mock_bootstrap_request;
   MockJournalReplayer mock_journal_replayer;
 
@@ -530,11 +428,6 @@ TEST_F(TestMockImageReplayer, StartStop) {
   expect_set_mirror_image_status_repeatedly();
 
   InSequence seq;
-  expect_send(mock_prepare_local_image_request, mock_local_image_ctx.id,
-              mock_local_image_ctx.name, "remote mirror uuid", 0);
-  expect_send(mock_prepare_remote_image_request, "remote mirror uuid",
-              m_remote_image_ctx->id, 0);
-  EXPECT_CALL(mock_remote_journaler, construct());
   expect_send(mock_bootstrap_request, mock_local_image_ctx, false, 0);
   expect_init(mock_journal_replayer, 0);
 
@@ -567,48 +460,13 @@ TEST_F(TestMockImageReplayer, LocalImagePrimary) {
   expect_add_event_after_repeatedly(mock_threads);
 
   MockImageDeleter mock_image_deleter;
-  MockPrepareLocalImageRequest mock_prepare_local_image_request;
-  MockPrepareRemoteImageRequest mock_prepare_remote_image_request;
 
   expect_set_mirror_image_status_repeatedly();
 
   InSequence seq;
-  expect_send(mock_prepare_local_image_request, mock_local_image_ctx.id,
-              mock_local_image_ctx.name, "", 0);
-  expect_send(mock_prepare_remote_image_request, "remote mirror uuid",
-              "remote image id", 0);
-  EXPECT_CALL(mock_remote_journaler, construct());
-  expect_mirror_image_status_exists(false);
-
-  create_image_replayer(mock_threads);
 
-  C_SaferCond start_ctx;
-  m_image_replayer->start(&start_ctx);
-  ASSERT_EQ(0, start_ctx.wait());
-}
-
-TEST_F(TestMockImageReplayer, LocalImageDNE) {
-  create_local_image();
-  librbd::MockTestImageCtx mock_local_image_ctx(*m_local_image_ctx);
-
-  journal::MockJournaler mock_remote_journaler;
-  MockThreads mock_threads(m_threads);
-  expect_work_queue_repeatedly(mock_threads);
-  expect_add_event_after_repeatedly(mock_threads);
-
-  MockImageDeleter mock_image_deleter;
-  MockPrepareLocalImageRequest mock_prepare_local_image_request;
-  MockPrepareRemoteImageRequest mock_prepare_remote_image_request;
   MockBootstrapRequest mock_bootstrap_request;
-
-  expect_set_mirror_image_status_repeatedly();
-
-  InSequence seq;
-  expect_send(mock_prepare_local_image_request, "", "", "", -ENOENT);
-  expect_send(mock_prepare_remote_image_request, "remote mirror uuid",
-              m_remote_image_ctx->id, 0);
-  EXPECT_CALL(mock_remote_journaler, construct());
-  expect_send(mock_bootstrap_request, mock_local_image_ctx, false, -EREMOTEIO);
+  expect_send(mock_bootstrap_request, mock_local_image_ctx, false, -ENOMSG);
 
   expect_mirror_image_status_exists(false);
 
@@ -616,55 +474,27 @@ TEST_F(TestMockImageReplayer, LocalImageDNE) {
 
   C_SaferCond start_ctx;
   m_image_replayer->start(&start_ctx);
-  ASSERT_EQ(-EREMOTEIO, start_ctx.wait());
+  ASSERT_EQ(0, start_ctx.wait());
 }
 
-TEST_F(TestMockImageReplayer, PrepareLocalImageError) {
+TEST_F(TestMockImageReplayer, BootstrapRemoteDeleted) {
   create_local_image();
   librbd::MockTestImageCtx mock_local_image_ctx(*m_local_image_ctx);
 
+  journal::MockJournaler mock_remote_journaler;
   MockThreads mock_threads(m_threads);
   expect_work_queue_repeatedly(mock_threads);
   expect_add_event_after_repeatedly(mock_threads);
 
   MockImageDeleter mock_image_deleter;
-  MockPrepareLocalImageRequest mock_prepare_local_image_request;
 
-  EXPECT_CALL(m_local_status_updater, set_mirror_image_status(_, _, _))
-    .WillRepeatedly(Invoke([](auto, auto, auto){}));
+  expect_set_mirror_image_status_repeatedly();
 
   InSequence seq;
-  expect_send(mock_prepare_local_image_request, mock_local_image_ctx.id,
-              mock_local_image_ctx.name, "remote mirror uuid", -EINVAL);
-  EXPECT_CALL(m_local_status_updater, exists(_))
-    .WillOnce(Return(false));
-
-  create_image_replayer(mock_threads);
-
-  C_SaferCond start_ctx;
-  m_image_replayer->start(&start_ctx);
-  ASSERT_EQ(-EINVAL, start_ctx.wait());
-}
 
-TEST_F(TestMockImageReplayer, GetRemoteImageIdDNE) {
-  create_local_image();
-  librbd::MockTestImageCtx mock_local_image_ctx(*m_local_image_ctx);
-
-  MockThreads mock_threads(m_threads);
-  expect_work_queue_repeatedly(mock_threads);
-  expect_add_event_after_repeatedly(mock_threads);
-
-  MockImageDeleter mock_image_deleter;
-  MockPrepareLocalImageRequest mock_prepare_local_image_request;
-  MockPrepareRemoteImageRequest mock_prepare_remote_image_request;
-
-  expect_set_mirror_image_status_repeatedly();
+  MockBootstrapRequest mock_bootstrap_request;
+  expect_send(mock_bootstrap_request, mock_local_image_ctx, false, -ENOLINK);
 
-  InSequence seq;
-  expect_send(mock_prepare_local_image_request, mock_local_image_ctx.id,
-              mock_local_image_ctx.name, "remote mirror uuid", 0);
-  expect_send(mock_prepare_remote_image_request, "remote mirror uuid",
-              "", -ENOENT);
   expect_trash_move(mock_image_deleter, "global image id", false, 0);
   expect_mirror_image_status_exists(false);
 
@@ -675,60 +505,35 @@ TEST_F(TestMockImageReplayer, GetRemoteImageIdDNE) {
   ASSERT_EQ(0, start_ctx.wait());
 }
 
-TEST_F(TestMockImageReplayer, GetRemoteImageIdNonLinkedDNE) {
+TEST_F(TestMockImageReplayer, BootstrapResyncRequested) {
   create_local_image();
   librbd::MockTestImageCtx mock_local_image_ctx(*m_local_image_ctx);
 
+  journal::MockJournaler mock_remote_journaler;
   MockThreads mock_threads(m_threads);
   expect_work_queue_repeatedly(mock_threads);
   expect_add_event_after_repeatedly(mock_threads);
 
   MockImageDeleter mock_image_deleter;
-  MockPrepareLocalImageRequest mock_prepare_local_image_request;
-  MockPrepareRemoteImageRequest mock_prepare_remote_image_request;
 
   expect_set_mirror_image_status_repeatedly();
 
   InSequence seq;
-  expect_send(mock_prepare_local_image_request, mock_local_image_ctx.id,
-              mock_local_image_ctx.name, "some other mirror uuid", 0);
-  expect_send(mock_prepare_remote_image_request, "remote mirror uuid",
-              "", -ENOENT);
-  expect_mirror_image_status_exists(false);
-
-  create_image_replayer(mock_threads);
 
-  C_SaferCond start_ctx;
-  m_image_replayer->start(&start_ctx);
-  ASSERT_EQ(-ENOENT, start_ctx.wait());
-}
-
-TEST_F(TestMockImageReplayer, GetRemoteImageIdError) {
-  create_local_image();
-  librbd::MockTestImageCtx mock_local_image_ctx(*m_local_image_ctx);
-
-  MockThreads mock_threads(m_threads);
-  expect_work_queue_repeatedly(mock_threads);
-  expect_add_event_after_repeatedly(mock_threads);
-
-  MockImageDeleter mock_image_deleter;
-  MockPrepareLocalImageRequest mock_prepare_local_image_request;
-  MockPrepareRemoteImageRequest mock_prepare_remote_image_request;
+  MockBootstrapRequest mock_bootstrap_request;
+  expect_send(mock_bootstrap_request, mock_local_image_ctx, true, 0);
 
-  expect_set_mirror_image_status_repeatedly();
+  MockCloseImageRequest mock_close_image_request;
+  expect_send(mock_close_image_request, 0);
 
-  InSequence seq;
-  expect_send(mock_prepare_local_image_request, mock_local_image_ctx.id,
-              mock_local_image_ctx.name, "remote mirror uuid", 0);
-  expect_send(mock_prepare_remote_image_request, "remote mirror uuid",
-              m_remote_image_ctx->id, -EINVAL);
+  expect_trash_move(mock_image_deleter, "global image id", true, 0);
   expect_mirror_image_status_exists(false);
 
   create_image_replayer(mock_threads);
 
   C_SaferCond start_ctx;
   m_image_replayer->start(&start_ctx);
-  ASSERT_EQ(-EINVAL, start_ctx.wait());
+  ASSERT_EQ(0, start_ctx.wait());
 }
 
 TEST_F(TestMockImageReplayer, BootstrapError) {
@@ -741,18 +546,11 @@ TEST_F(TestMockImageReplayer, BootstrapError) {
   expect_add_event_after_repeatedly(mock_threads);
 
   MockImageDeleter mock_image_deleter;
-  MockPrepareLocalImageRequest mock_prepare_local_image_request;
-  MockPrepareRemoteImageRequest mock_prepare_remote_image_request;
   MockBootstrapRequest mock_bootstrap_request;
 
   expect_set_mirror_image_status_repeatedly();
 
   InSequence seq;
-  expect_send(mock_prepare_local_image_request, mock_local_image_ctx.id,
-              mock_local_image_ctx.name, "remote mirror uuid", 0);
-  expect_send(mock_prepare_remote_image_request, "remote mirror uuid",
-              m_remote_image_ctx->id, 0);
-  EXPECT_CALL(mock_remote_journaler, construct());
   expect_send(mock_bootstrap_request, mock_local_image_ctx, false, -EINVAL);
 
   expect_mirror_image_status_exists(false);
@@ -764,7 +562,7 @@ TEST_F(TestMockImageReplayer, BootstrapError) {
   ASSERT_EQ(-EINVAL, start_ctx.wait());
 }
 
-TEST_F(TestMockImageReplayer, StopBeforeBootstrap) {
+TEST_F(TestMockImageReplayer, BootstrapCancel) {
   create_local_image();
   librbd::MockTestImageCtx mock_local_image_ctx(*m_local_image_ctx);
 
@@ -774,25 +572,23 @@ TEST_F(TestMockImageReplayer, StopBeforeBootstrap) {
   expect_add_event_after_repeatedly(mock_threads);
 
   MockImageDeleter mock_image_deleter;
-  MockPrepareLocalImageRequest mock_prepare_local_image_request;
-  MockPrepareRemoteImageRequest mock_prepare_remote_image_request;
 
   expect_set_mirror_image_status_repeatedly();
 
   InSequence seq;
-  expect_send(mock_prepare_local_image_request, mock_local_image_ctx.id,
-              mock_local_image_ctx.name, "remote mirror uuid", 0);
-  expect_send(mock_prepare_remote_image_request, "remote mirror uuid",
-              m_remote_image_ctx->id, 0);
-  EXPECT_CALL(mock_remote_journaler, construct())
-    .WillOnce(Invoke([this]() {
-                m_image_replayer->stop(nullptr, true);
-              }));
-
-  expect_mirror_image_status_exists(false);
 
   create_image_replayer(mock_threads);
 
+  MockBootstrapRequest mock_bootstrap_request;
+  EXPECT_CALL(mock_bootstrap_request, send())
+    .WillOnce(Invoke([this, &mock_bootstrap_request]() {
+        m_image_replayer->stop();
+        mock_bootstrap_request.on_finish->complete(-ECANCELED);
+      }));
+  EXPECT_CALL(mock_bootstrap_request, cancel());
+
+  expect_mirror_image_status_exists(false);
+
   C_SaferCond start_ctx;
   m_image_replayer->start(&start_ctx);
   ASSERT_EQ(-ECANCELED, start_ctx.wait());
@@ -810,8 +606,6 @@ TEST_F(TestMockImageReplayer, StopError) {
   expect_add_event_after_repeatedly(mock_threads);
 
   MockImageDeleter mock_image_deleter;
-  MockPrepareLocalImageRequest mock_prepare_local_image_request;
-  MockPrepareRemoteImageRequest mock_prepare_remote_image_request;
   MockBootstrapRequest mock_bootstrap_request;
   MockJournalReplayer mock_journal_replayer;
 
@@ -819,11 +613,6 @@ TEST_F(TestMockImageReplayer, StopError) {
   expect_set_mirror_image_status_repeatedly();
 
   InSequence seq;
-  expect_send(mock_prepare_local_image_request, mock_local_image_ctx.id,
-              mock_local_image_ctx.name, "remote mirror uuid", 0);
-  expect_send(mock_prepare_remote_image_request, "remote mirror uuid",
-              m_remote_image_ctx->id, 0);
-  EXPECT_CALL(mock_remote_journaler, construct());
   expect_send(mock_bootstrap_request, mock_local_image_ctx, false, 0);
   expect_init(mock_journal_replayer, 0);
 
@@ -853,19 +642,12 @@ TEST_F(TestMockImageReplayer, ReplayerError) {
   expect_add_event_after_repeatedly(mock_threads);
 
   MockImageDeleter mock_image_deleter;
-  MockPrepareLocalImageRequest mock_prepare_local_image_request;
-  MockPrepareRemoteImageRequest mock_prepare_remote_image_request;
   MockBootstrapRequest mock_bootstrap_request;
   MockJournalReplayer mock_journal_replayer;
 
   expect_set_mirror_image_status_repeatedly();
 
   InSequence seq;
-  expect_send(mock_prepare_local_image_request, mock_local_image_ctx.id,
-              mock_local_image_ctx.name, "remote mirror uuid", 0);
-  expect_send(mock_prepare_remote_image_request, "remote mirror uuid",
-              m_remote_image_ctx->id, 0);
-  EXPECT_CALL(mock_remote_journaler, construct());
   expect_send(mock_bootstrap_request, mock_local_image_ctx, false, 0);
   expect_init(mock_journal_replayer, -EINVAL);
   EXPECT_CALL(mock_journal_replayer, get_error_description())
@@ -891,8 +673,6 @@ TEST_F(TestMockImageReplayer, ReplayerResync) {
   expect_add_event_after_repeatedly(mock_threads);
 
   MockImageDeleter mock_image_deleter;
-  MockPrepareLocalImageRequest mock_prepare_local_image_request;
-  MockPrepareRemoteImageRequest mock_prepare_remote_image_request;
   MockBootstrapRequest mock_bootstrap_request;
   MockJournalReplayer mock_journal_replayer;
 
@@ -900,11 +680,6 @@ TEST_F(TestMockImageReplayer, ReplayerResync) {
   expect_set_mirror_image_status_repeatedly();
 
   InSequence seq;
-  expect_send(mock_prepare_local_image_request, mock_local_image_ctx.id,
-              mock_local_image_ctx.name, "remote mirror uuid", 0);
-  expect_send(mock_prepare_remote_image_request, "remote mirror uuid",
-              m_remote_image_ctx->id, 0);
-  EXPECT_CALL(mock_remote_journaler, construct());
   expect_send(mock_bootstrap_request, mock_local_image_ctx, false, 0);
   expect_init(mock_journal_replayer, 0);
 
@@ -937,8 +712,6 @@ TEST_F(TestMockImageReplayer, ReplayerInterrupted) {
   expect_add_event_after_repeatedly(mock_threads);
 
   MockImageDeleter mock_image_deleter;
-  MockPrepareLocalImageRequest mock_prepare_local_image_request;
-  MockPrepareRemoteImageRequest mock_prepare_remote_image_request;
   MockBootstrapRequest mock_bootstrap_request;
   MockJournalReplayer mock_journal_replayer;
 
@@ -946,11 +719,6 @@ TEST_F(TestMockImageReplayer, ReplayerInterrupted) {
   expect_set_mirror_image_status_repeatedly();
 
   InSequence seq;
-  expect_send(mock_prepare_local_image_request, mock_local_image_ctx.id,
-              mock_local_image_ctx.name, "remote mirror uuid", 0);
-  expect_send(mock_prepare_remote_image_request, "remote mirror uuid",
-              m_remote_image_ctx->id, 0);
-  EXPECT_CALL(mock_remote_journaler, construct());
   expect_send(mock_bootstrap_request, mock_local_image_ctx, false, 0);
   expect_init(mock_journal_replayer, 0);
 
@@ -988,8 +756,6 @@ TEST_F(TestMockImageReplayer, ReplayerRenamed) {
   expect_add_event_after_repeatedly(mock_threads);
 
   MockImageDeleter mock_image_deleter;
-  MockPrepareLocalImageRequest mock_prepare_local_image_request;
-  MockPrepareRemoteImageRequest mock_prepare_remote_image_request;
   MockBootstrapRequest mock_bootstrap_request;
   MockJournalReplayer mock_journal_replayer;
 
@@ -997,11 +763,6 @@ TEST_F(TestMockImageReplayer, ReplayerRenamed) {
   expect_set_mirror_image_status_repeatedly();
 
   InSequence seq;
-  expect_send(mock_prepare_local_image_request, mock_local_image_ctx.id,
-              mock_local_image_ctx.name, "remote mirror uuid", 0);
-  expect_send(mock_prepare_remote_image_request, "remote mirror uuid",
-              m_remote_image_ctx->id, 0);
-  EXPECT_CALL(mock_remote_journaler, construct());
   expect_send(mock_bootstrap_request, mock_local_image_ctx, false, 0);
   expect_init(mock_journal_replayer, 0);
 
diff --git a/src/tools/rbd_mirror/ImageReplayer.cc b/src/tools/rbd_mirror/ImageReplayer.cc
index 27fbc4b7378..f75d2962f50 100644
--- a/src/tools/rbd_mirror/ImageReplayer.cc
+++ b/src/tools/rbd_mirror/ImageReplayer.cc
@@ -12,7 +12,6 @@
 #include "common/WorkQueue.h"
 #include "global/global_context.h"
 #include "journal/Journaler.h"
-#include "journal/Settings.h"
 #include "librbd/ExclusiveLock.h"
 #include "librbd/ImageCtx.h"
 #include "librbd/ImageState.h"
@@ -25,8 +24,6 @@
 #include "Threads.h"
 #include "tools/rbd_mirror/image_replayer/BootstrapRequest.h"
 #include "tools/rbd_mirror/image_replayer/CloseImageRequest.h"
-#include "tools/rbd_mirror/image_replayer/PrepareLocalImageRequest.h"
-#include "tools/rbd_mirror/image_replayer/PrepareRemoteImageRequest.h"
 #include "tools/rbd_mirror/image_replayer/ReplayerListener.h"
 #include "tools/rbd_mirror/image_replayer/Utils.h"
 #include "tools/rbd_mirror/image_replayer/journal/Replayer.h"
@@ -326,45 +323,19 @@ void ImageReplayer<I>::start(Context *on_finish, bool manual)
     return;
   }
 
-  prepare_local_image();
+  bootstrap();
 }
 
 template <typename I>
-void ImageReplayer<I>::prepare_local_image() {
+void ImageReplayer<I>::bootstrap() {
   dout(10) << dendl;
 
-  m_local_image_id = "";
-  Context *ctx = create_context_callback<
-    ImageReplayer, &ImageReplayer<I>::handle_prepare_local_image>(this);
-  auto req = image_replayer::PrepareLocalImageRequest<I>::create(
-    m_local_io_ctx, m_global_image_id, &m_local_image_id, &m_local_image_name,
-    &m_local_image_tag_owner, m_threads->work_queue, ctx);
-  req->send();
-}
-
-template <typename I>
-void ImageReplayer<I>::handle_prepare_local_image(int r) {
-  dout(10) << "r=" << r << dendl;
-
-  if (r == -ENOENT) {
-    dout(10) << "local image does not exist" << dendl;
-  } else if (r < 0) {
-    on_start_fail(r, "error preparing local image for replay");
-    return;
-  } else {
-    // have the correct local image name now
-    reregister_admin_socket_hook();
-  }
-
-  prepare_remote_image();
-}
-
-template <typename I>
-void ImageReplayer<I>::prepare_remote_image() {
-  dout(10) << dendl;
+  std::unique_lock locker{m_lock};
   if (m_peers.empty()) {
-    // technically nothing to bootstrap, but it handles the status update
-    bootstrap();
+    locker.unlock();
+
+    dout(5) << "no peer clusters" << dendl;
+    on_start_fail(-ENOENT, "no peer clusters");
     return;
   }
 
@@ -372,91 +343,25 @@ void ImageReplayer<I>::prepare_remote_image() {
   ceph_assert(!m_peers.empty());
   m_remote_image = {*m_peers.begin()};
 
-  auto cct = static_cast<CephContext *>(m_local_io_ctx.cct());
-  journal::Settings journal_settings;
-  journal_settings.commit_interval = cct->_conf.get_val<double>(
-    "rbd_mirror_journal_commit_age");
-
-  ceph_assert(m_remote_journaler == nullptr);
-
-  Context *ctx = create_context_callback<
-    ImageReplayer, &ImageReplayer<I>::handle_prepare_remote_image>(this);
-  auto req = image_replayer::PrepareRemoteImageRequest<I>::create(
-    m_threads, m_remote_image.io_ctx, m_global_image_id, m_local_mirror_uuid,
-    m_local_image_id, journal_settings, m_cache_manager_handler,
-    &m_remote_image.mirror_uuid, &m_remote_image.image_id, &m_remote_journaler,
-    &m_client_state, &m_client_meta, ctx);
-  req->send();
-}
-
-template <typename I>
-void ImageReplayer<I>::handle_prepare_remote_image(int r) {
-  dout(10) << "r=" << r << dendl;
-
-  ceph_assert(r < 0 ? m_remote_journaler == nullptr :
-                      m_remote_journaler != nullptr);
-  if (r < 0 && !m_local_image_id.empty() &&
-      m_local_image_tag_owner == librbd::Journal<>::LOCAL_MIRROR_UUID) {
-    // local image is primary -- fall-through
-  } else if (r == -ENOENT) {
-    dout(10) << "remote image does not exist" << dendl;
-
-    // TODO need to support multiple remote images
-    if (m_remote_image.image_id.empty() && !m_local_image_id.empty() &&
-        m_local_image_tag_owner == m_remote_image.mirror_uuid) {
-      // local image exists and is non-primary and linked to the missing
-      // remote image
-
-      m_delete_requested = true;
-      on_start_fail(0, "remote image no longer exists");
-    } else {
-      on_start_fail(-ENOENT, "remote image does not exist");
-    }
-    return;
-  } else if (r < 0) {
-    on_start_fail(r, "error retrieving remote image id");
+  if (on_start_interrupted(m_lock)) {
     return;
   }
 
-  bootstrap();
-}
-
-template <typename I>
-void ImageReplayer<I>::bootstrap() {
-  dout(10) << dendl;
-
-  if (!m_local_image_id.empty() &&
-      m_local_image_tag_owner == librbd::Journal<>::LOCAL_MIRROR_UUID) {
-    dout(5) << "local image is primary" << dendl;
-    on_start_fail(0, "local image is primary");
-    return;
-  } else if (m_peers.empty()) {
-    dout(5) << "no peer clusters" << dendl;
-    on_start_fail(-ENOENT, "no peer clusters");
-    return;
-  }
-
-  image_replayer::BootstrapRequest<I> *request = nullptr;
-  {
-    std::lock_guard locker{m_lock};
-    if (on_start_interrupted(m_lock)) {
-      return;
-    }
-
-    auto ctx = create_context_callback<
+  m_local_image_id = "";
+  auto ctx = create_context_callback<
       ImageReplayer, &ImageReplayer<I>::handle_bootstrap>(this);
-    request = image_replayer::BootstrapRequest<I>::create(
+  auto request = image_replayer::BootstrapRequest<I>::create(
       m_threads, m_local_io_ctx, m_remote_image.io_ctx, m_instance_watcher,
-      &m_local_image_ctx, m_local_image_id, m_remote_image.image_id,
-      m_global_image_id, m_local_mirror_uuid, m_remote_image.mirror_uuid,
-      m_remote_journaler, &m_client_state, &m_client_meta, ctx,
-      &m_resync_requested, &m_progress_cxt);
-    request->get();
-    m_bootstrap_request = request;
-  }
+      m_remote_image.image_id, m_global_image_id, m_local_mirror_uuid,
+      m_cache_manager_handler, &m_progress_cxt, &m_local_image_ctx,
+      &m_local_image_id, &m_remote_image.mirror_uuid, &m_remote_journaler,
+      &m_resync_requested, ctx);
 
-  update_mirror_image_status(false, boost::none);
+  request->get();
+  m_bootstrap_request = request;
+  locker.unlock();
 
+  update_mirror_image_status(false, boost::none);
   request->send();
 }
 
@@ -474,15 +379,21 @@ void ImageReplayer<I>::handle_bootstrap(int r) {
 
   if (on_start_interrupted()) {
     return;
+  } else if (r == -ENOMSG) {
+    dout(5) << "local image is primary" << dendl;
+    on_start_fail(0, "local image is primary");
+    return;
   } else if (r == -EREMOTEIO) {
-    m_local_image_tag_owner = "";
     dout(5) << "remote image is non-primary" << dendl;
     on_start_fail(-EREMOTEIO, "remote image is non-primary");
     return;
   } else if (r == -EEXIST) {
-    m_local_image_tag_owner = "";
     on_start_fail(r, "split-brain detected");
     return;
+  } else if (r == -ENOLINK) {
+    m_delete_requested = true;
+    on_start_fail(0, "remote image no longer exists");
+    return;
   } else if (r < 0) {
     on_start_fail(r, "error bootstrapping replay");
     return;
@@ -1143,16 +1054,20 @@ void ImageReplayer<I>::unregister_admin_socket_hook() {
 
 template <typename I>
 void ImageReplayer<I>::reregister_admin_socket_hook() {
-  {
-    std::lock_guard locker{m_lock};
+  std::unique_lock locker{m_lock};
+  if (m_state == STATE_STARTING && m_bootstrap_request != nullptr) {
+    m_local_image_name = m_bootstrap_request->get_local_image_name();
+  }
 
-    auto image_spec = image_replayer::util::compute_image_spec(
-      m_local_io_ctx, m_local_image_name);
-    if (m_asok_hook != nullptr && m_image_spec == image_spec) {
-      return;
-    }
-    m_image_spec = image_spec;
+  auto image_spec = image_replayer::util::compute_image_spec(
+    m_local_io_ctx, m_local_image_name);
+  if (m_asok_hook != nullptr && m_image_spec == image_spec) {
+    return;
   }
+
+  m_image_spec = image_spec;
+  locker.unlock();
+
   unregister_admin_socket_hook();
   register_admin_socket_hook();
 }
diff --git a/src/tools/rbd_mirror/ImageReplayer.h b/src/tools/rbd_mirror/ImageReplayer.h
index 5b6165422ec..3ac9d16548d 100644
--- a/src/tools/rbd_mirror/ImageReplayer.h
+++ b/src/tools/rbd_mirror/ImageReplayer.h
@@ -131,12 +131,6 @@ protected:
    * <starting>                                             *
    *    |                                                   *
    *    v                                           (error) *
-   * PREPARE_LOCAL_IMAGE  * * * * * * * * * * * * * * * * * *
-   *    |                                                   *
-   *    v                                           (error) *
-   * PREPARE_REMOTE_IMAGE * * * * * * * * * * * * * * * * * *
-   *    |                                                   *
-   *    v                                           (error) *
    * BOOTSTRAP_IMAGE  * * * * * * * * * * * * * * * * * * * *
    *    |                                                   *
    *    v                                           (error) *
@@ -202,7 +196,8 @@ private:
     }
 
     void update_progress(const std::string &description,
-				 bool flush = true) override;
+                         bool flush = true) override;
+
   private:
     ImageReplayer<ImageCtxT> *replayer;
   };
@@ -237,7 +232,6 @@ private:
   bool m_resync_requested = false;
 
   ImageCtxT *m_local_image_ctx = nullptr;
-  std::string m_local_image_tag_owner;
 
   decltype(ImageCtxT::journal) m_local_journal = nullptr;
   Journaler* m_remote_journaler = nullptr;
@@ -254,10 +248,6 @@ private:
 
   image_replayer::BootstrapRequest<ImageCtxT> *m_bootstrap_request = nullptr;
 
-  cls::journal::ClientState m_client_state =
-    cls::journal::CLIENT_STATE_DISCONNECTED;
-  librbd::journal::MirrorPeerClientMeta m_client_meta;
-
   AsyncOpTracker m_in_flight_op_tracker;
 
   static std::string to_string(const State state);
@@ -278,12 +268,6 @@ private:
   void shut_down(int r);
   void handle_shut_down(int r);
 
-  void prepare_local_image();
-  void handle_prepare_local_image(int r);
-
-  void prepare_remote_image();
-  void handle_prepare_remote_image(int r);
-
   void bootstrap();
   void handle_bootstrap(int r);
 
diff --git a/src/tools/rbd_mirror/image_replayer/BootstrapRequest.cc b/src/tools/rbd_mirror/image_replayer/BootstrapRequest.cc
index 3a3186f8d69..16143f823fa 100644
--- a/src/tools/rbd_mirror/image_replayer/BootstrapRequest.cc
+++ b/src/tools/rbd_mirror/image_replayer/BootstrapRequest.cc
@@ -13,6 +13,7 @@
 #include "common/WorkQueue.h"
 #include "cls/rbd/cls_rbd_client.h"
 #include "journal/Journaler.h"
+#include "journal/Settings.h"
 #include "librbd/ImageCtx.h"
 #include "librbd/ImageState.h"
 #include "librbd/internal.h"
@@ -23,6 +24,8 @@
 #include "tools/rbd_mirror/ProgressContext.h"
 #include "tools/rbd_mirror/ImageSync.h"
 #include "tools/rbd_mirror/Threads.h"
+#include "tools/rbd_mirror/image_replayer/PrepareLocalImageRequest.h"
+#include "tools/rbd_mirror/image_replayer/PrepareRemoteImageRequest.h"
 #include "tools/rbd_mirror/image_replayer/journal/CreateLocalImageRequest.h"
 #include "tools/rbd_mirror/image_replayer/journal/PrepareReplayRequest.h"
 
@@ -42,33 +45,37 @@ using librbd::util::unique_lock_name;
 
 template <typename I>
 BootstrapRequest<I>::BootstrapRequest(
-        Threads<I>* threads,
-        librados::IoCtx &local_io_ctx,
-        librados::IoCtx &remote_io_ctx,
-        InstanceWatcher<I> *instance_watcher,
-        I **local_image_ctx,
-        const std::string &local_image_id,
-        const std::string &remote_image_id,
-        const std::string &global_image_id,
-        const std::string &local_mirror_uuid,
-        const std::string &remote_mirror_uuid,
-        Journaler *remote_journaler,
-        cls::journal::ClientState *client_state,
-        MirrorPeerClientMeta *client_meta,
-        Context *on_finish,
-        bool *do_resync,
-        rbd::mirror::ProgressContext *progress_ctx)
+    Threads<I>* threads,
+    librados::IoCtx& local_io_ctx,
+    librados::IoCtx& remote_io_ctx,
+    InstanceWatcher<I>* instance_watcher,
+    const std::string& remote_image_id,
+    const std::string& global_image_id,
+    const std::string& local_mirror_uuid,
+    ::journal::CacheManagerHandler* cache_manager_handler,
+    ProgressContext* progress_ctx,
+    I** local_image_ctx,
+    std::string* local_image_id,
+    std::string* remote_mirror_uuid,
+    Journaler** remote_journaler,
+    bool* do_resync,
+    Context* on_finish)
   : BaseRequest("rbd::mirror::image_replayer::BootstrapRequest",
 		reinterpret_cast<CephContext*>(local_io_ctx.cct()), on_finish),
-    m_threads(threads), m_local_io_ctx(local_io_ctx),
-    m_remote_io_ctx(remote_io_ctx), m_instance_watcher(instance_watcher),
-    m_local_image_ctx(local_image_ctx), m_local_image_id(local_image_id),
-    m_remote_image_id(remote_image_id), m_global_image_id(global_image_id),
+    m_threads(threads),
+    m_local_io_ctx(local_io_ctx),
+    m_remote_io_ctx(remote_io_ctx),
+    m_instance_watcher(instance_watcher),
+    m_remote_image_id(remote_image_id),
+    m_global_image_id(global_image_id),
     m_local_mirror_uuid(local_mirror_uuid),
+    m_cache_manager_handler(cache_manager_handler),
+    m_progress_ctx(progress_ctx),
+    m_local_image_ctx(local_image_ctx),
+    m_local_image_id(local_image_id),
     m_remote_mirror_uuid(remote_mirror_uuid),
     m_remote_journaler(remote_journaler),
-    m_client_state(client_state), m_client_meta(client_meta),
-    m_progress_ctx(progress_ctx), m_do_resync(do_resync),
+    m_do_resync(do_resync),
     m_lock(ceph::make_mutex(unique_lock_name("BootstrapRequest::m_lock",
                                              this))) {
   dout(10) << dendl;
@@ -89,7 +96,7 @@ template <typename I>
 void BootstrapRequest<I>::send() {
   *m_do_resync = false;
 
-  open_remote_image();
+  prepare_local_image();
 }
 
 template <typename I>
@@ -105,6 +112,112 @@ void BootstrapRequest<I>::cancel() {
 }
 
 template <typename I>
+std::string BootstrapRequest<I>::get_local_image_name() const {
+  std::unique_lock locker{m_lock};
+  return m_local_image_name;
+}
+
+template <typename I>
+void BootstrapRequest<I>::prepare_local_image() {
+  dout(10) << dendl;
+  update_progress("PREPARE_LOCAL_IMAGE");
+
+  *m_local_image_id = "";
+  m_local_image_name = m_global_image_id;
+  auto ctx = create_context_callback<
+    BootstrapRequest, &BootstrapRequest<I>::handle_prepare_local_image>(this);
+  auto req = image_replayer::PrepareLocalImageRequest<I>::create(
+    m_local_io_ctx, m_global_image_id, m_local_image_id,
+    &m_prepare_local_image_name, &m_local_image_tag_owner,
+    m_threads->work_queue, ctx);
+  req->send();
+}
+
+template <typename I>
+void BootstrapRequest<I>::handle_prepare_local_image(int r) {
+  dout(10) << "r=" << r << dendl;
+
+  if (r == -ENOENT) {
+    dout(10) << "local image does not exist" << dendl;
+  } else if (r < 0) {
+    derr << "error preparing local image for replay" << cpp_strerror(r)
+         << dendl;
+    finish(r);
+    return;
+  }
+
+  // image replayer will detect the name change (if any) at next
+  // status update
+  {
+    std::unique_lock locker{m_lock};
+    m_local_image_name = m_prepare_local_image_name;
+  }
+
+  prepare_remote_image();
+}
+
+template <typename I>
+void BootstrapRequest<I>::prepare_remote_image() {
+  dout(10) << dendl;
+  update_progress("PREPARE_REMOTE_IMAGE");
+
+  auto cct = static_cast<CephContext *>(m_local_io_ctx.cct());
+  ::journal::Settings journal_settings;
+  journal_settings.commit_interval = cct->_conf.get_val<double>(
+    "rbd_mirror_journal_commit_age");
+
+  ceph_assert(*m_remote_journaler == nullptr);
+
+  Context *ctx = create_context_callback<
+    BootstrapRequest, &BootstrapRequest<I>::handle_prepare_remote_image>(this);
+  auto req = image_replayer::PrepareRemoteImageRequest<I>::create(
+    m_threads, m_remote_io_ctx, m_global_image_id, m_local_mirror_uuid,
+    *m_local_image_id, journal_settings, m_cache_manager_handler,
+    m_remote_mirror_uuid, &m_remote_image_id, m_remote_journaler,
+    &m_client_state, &m_client_meta, ctx);
+  req->send();
+}
+
+template <typename I>
+void BootstrapRequest<I>::handle_prepare_remote_image(int r) {
+  dout(10) << "r=" << r << dendl;
+
+  ceph_assert(r < 0 ? *m_remote_journaler == nullptr :
+                      *m_remote_journaler != nullptr);
+  if (r < 0 && !m_local_image_id->empty() &&
+      m_local_image_tag_owner == librbd::Journal<>::LOCAL_MIRROR_UUID) {
+    // local image is primary -- fall-through
+  } else if (r == -ENOENT) {
+    dout(10) << "remote image does not exist" << dendl;
+
+    // TODO need to support multiple remote images
+    if (m_remote_image_id.empty() && !m_local_image_id->empty() &&
+        m_local_image_tag_owner == *m_remote_mirror_uuid) {
+      // local image exists and is non-primary and linked to the missing
+      // remote image
+      finish(-ENOLINK);
+    } else {
+      dout(10) << "remote image does not exist" << dendl;
+      finish(-ENOENT);
+    }
+    return;
+  } else if (r < 0) {
+    derr << "error retrieving remote image id" << cpp_strerror(r) << dendl;
+    finish(r);
+    return;
+  }
+
+  if (!m_local_image_id->empty() &&
+      m_local_image_tag_owner == librbd::Journal<>::LOCAL_MIRROR_UUID) {
+    dout(5) << "local image is primary" << dendl;
+    finish(-ENOMSG);
+    return;
+  }
+
+  open_remote_image();
+}
+
+template <typename I>
 void BootstrapRequest<I>::open_remote_image() {
   dout(15) << "remote_image_id=" << m_remote_image_id << dendl;
 
@@ -180,7 +293,7 @@ void BootstrapRequest<I>::handle_get_remote_mirror_info(int r) {
   }
 
   if (m_promotion_state != librbd::mirror::PROMOTION_STATE_PRIMARY &&
-      m_local_image_id.empty()) {
+      m_local_image_id->empty()) {
     // no local image and remote isn't primary -- don't sync it
     dout(5) << "remote image is not primary -- not syncing"
             << dendl;
@@ -189,13 +302,13 @@ void BootstrapRequest<I>::handle_get_remote_mirror_info(int r) {
     return;
   }
 
-  if (!m_client_meta->image_id.empty()) {
+  if (!m_client_meta.image_id.empty()) {
     // have an image id -- use that to open the image since a deletion (resync)
     // will leave the old image id registered in the peer
-    m_local_image_id = m_client_meta->image_id;
+    *m_local_image_id = m_client_meta.image_id;
   }
 
-  if (m_local_image_id.empty()) {
+  if (m_local_image_id->empty()) {
     create_local_image();
     return;
   }
@@ -205,7 +318,7 @@ void BootstrapRequest<I>::handle_get_remote_mirror_info(int r) {
 
 template <typename I>
 void BootstrapRequest<I>::open_local_image() {
-  dout(15) << "local_image_id=" << m_local_image_id << dendl;
+  dout(15) << "local_image_id=" << *m_local_image_id << dendl;
 
   update_progress("OPEN_LOCAL_IMAGE");
 
@@ -213,7 +326,7 @@ void BootstrapRequest<I>::open_local_image() {
     BootstrapRequest<I>, &BootstrapRequest<I>::handle_open_local_image>(
       this);
   OpenLocalImageRequest<I> *request = OpenLocalImageRequest<I>::create(
-    m_local_io_ctx, m_local_image_ctx, m_local_image_id, m_threads->work_queue,
+    m_local_io_ctx, m_local_image_ctx, *m_local_image_id, m_threads->work_queue,
     ctx);
   request->send();
 }
@@ -254,8 +367,8 @@ void BootstrapRequest<I>::prepare_replay() {
     BootstrapRequest<I>,
     &BootstrapRequest<I>::handle_prepare_replay>(this);
   auto request = journal::PrepareReplayRequest<I>::create(
-    *m_local_image_ctx, m_remote_journaler, m_promotion_state,
-    m_local_mirror_uuid, m_remote_mirror_uuid, m_client_meta,
+    *m_local_image_ctx, *m_remote_journaler, m_promotion_state,
+    m_local_mirror_uuid, *m_remote_mirror_uuid, &m_client_meta,
     m_progress_ctx, m_do_resync, &m_syncing, ctx);
   request->send();
 }
@@ -275,7 +388,7 @@ void BootstrapRequest<I>::handle_prepare_replay(int r) {
     dout(10) << "local image resync requested" << dendl;
     close_remote_image();
     return;
-  } else if (*m_client_state == cls::journal::CLIENT_STATE_DISCONNECTED) {
+  } else if (m_client_state == cls::journal::CLIENT_STATE_DISCONNECTED) {
     dout(10) << "client flagged disconnected -- skipping bootstrap" << dendl;
     // The caller is expected to detect disconnect initializing remote journal.
     m_ret_val = 0;
@@ -300,9 +413,9 @@ void BootstrapRequest<I>::create_local_image() {
     BootstrapRequest<I>,
     &BootstrapRequest<I>::handle_create_local_image>(this);
   auto request = journal::CreateLocalImageRequest<I>::create(
-    m_threads, m_local_io_ctx, m_remote_image_ctx, m_remote_journaler,
-    m_global_image_id, m_remote_mirror_uuid, m_client_meta, m_progress_ctx,
-    &m_local_image_id, ctx);
+    m_threads, m_local_io_ctx, m_remote_image_ctx, *m_remote_journaler,
+    m_global_image_id, *m_remote_mirror_uuid, &m_client_meta, m_progress_ctx,
+    m_local_image_id, ctx);
   request->send();
 }
 
@@ -321,7 +434,7 @@ void BootstrapRequest<I>::handle_create_local_image(int r) {
     return;
   }
 
-  *m_client_state = cls::journal::CLIENT_STATE_CONNECTED;
+  m_client_state = cls::journal::CLIENT_STATE_CONNECTED;
 
   open_local_image();
 }
@@ -345,8 +458,8 @@ void BootstrapRequest<I>::image_sync() {
     BootstrapRequest<I>, &BootstrapRequest<I>::handle_image_sync>(this);
   m_image_sync = ImageSync<I>::create(
     *m_local_image_ctx, m_remote_image_ctx, m_threads->timer,
-    &m_threads->timer_lock, m_local_mirror_uuid, m_remote_journaler,
-    m_client_meta, m_threads->work_queue, m_instance_watcher, ctx,
+    &m_threads->timer_lock, m_local_mirror_uuid, *m_remote_journaler,
+    &m_client_meta, m_threads->work_queue, m_instance_watcher, ctx,
     m_progress_ctx);
   m_image_sync->get();
   locker.unlock();
diff --git a/src/tools/rbd_mirror/image_replayer/BootstrapRequest.h b/src/tools/rbd_mirror/image_replayer/BootstrapRequest.h
index be1bc043d2c..33adc7bdee3 100644
--- a/src/tools/rbd_mirror/image_replayer/BootstrapRequest.h
+++ b/src/tools/rbd_mirror/image_replayer/BootstrapRequest.h
@@ -20,6 +20,8 @@
 class Context;
 class ContextWQ;
 class SafeTimer;
+
+namespace journal { class CacheManagerHandler; }
 namespace librbd { class ImageCtx; }
 
 namespace rbd {
@@ -42,45 +44,44 @@ public:
   typedef rbd::mirror::ProgressContext ProgressContext;
 
   static BootstrapRequest* create(
-        Threads<ImageCtxT>* threads,
-        librados::IoCtx &local_io_ctx,
-        librados::IoCtx &remote_io_ctx,
-        InstanceWatcher<ImageCtxT> *instance_watcher,
-        ImageCtxT **local_image_ctx,
-        const std::string &local_image_id,
-        const std::string &remote_image_id,
-        const std::string &global_image_id,
-        const std::string &local_mirror_uuid,
-        const std::string &remote_mirror_uuid,
-        Journaler *remote_journaler,
-        cls::journal::ClientState *client_state,
-        MirrorPeerClientMeta *client_meta,
-        Context *on_finish,
-        bool *do_resync,
-        ProgressContext *progress_ctx = nullptr) {
-    return new BootstrapRequest(threads, local_io_ctx, remote_io_ctx,
-                                instance_watcher, local_image_ctx,
-                                local_image_id, remote_image_id,
-                                global_image_id, local_mirror_uuid,
-                                remote_mirror_uuid, remote_journaler,
-                                client_state, client_meta, on_finish,
-                                do_resync, progress_ctx);
+      Threads<ImageCtxT>* threads,
+      librados::IoCtx& local_io_ctx,
+      librados::IoCtx& remote_io_ctx,
+      InstanceWatcher<ImageCtxT>* instance_watcher,
+      const std::string& remote_image_id,
+      const std::string& global_image_id,
+      const std::string& local_mirror_uuid,
+      ::journal::CacheManagerHandler* cache_manager_handler,
+      ProgressContext* progress_ctx,
+      ImageCtxT** local_image_ctx,
+      std::string* local_image_id,
+      std::string* remote_mirror_uuid,
+      Journaler** remote_journaler,
+      bool* do_resync,
+      Context* on_finish) {
+    return new BootstrapRequest(
+      threads, local_io_ctx, remote_io_ctx, instance_watcher, remote_image_id,
+      global_image_id, local_mirror_uuid,  cache_manager_handler, progress_ctx,
+      local_image_ctx, local_image_id, remote_mirror_uuid, remote_journaler,
+      do_resync, on_finish);
   }
 
-  BootstrapRequest(Threads<ImageCtxT>* threads,
-                   librados::IoCtx &local_io_ctx,
-                   librados::IoCtx &remote_io_ctx,
-                   InstanceWatcher<ImageCtxT> *instance_watcher,
-                   ImageCtxT **local_image_ctx,
-                   const std::string &local_image_id,
-                   const std::string &remote_image_id,
-                   const std::string &global_image_id,
-                   const std::string &local_mirror_uuid,
-                   const std::string &remote_mirror_uuid,
-                   Journaler *remote_journaler,
-                   cls::journal::ClientState *client_state,
-                   MirrorPeerClientMeta *client_meta, Context *on_finish,
-                   bool *do_resync, ProgressContext *progress_ctx = nullptr);
+  BootstrapRequest(
+      Threads<ImageCtxT>* threads,
+      librados::IoCtx& local_io_ctx,
+      librados::IoCtx& remote_io_ctx,
+      InstanceWatcher<ImageCtxT>* instance_watcher,
+      const std::string& remote_image_id,
+      const std::string& global_image_id,
+      const std::string& local_mirror_uuid,
+      ::journal::CacheManagerHandler* cache_manager_handler,
+      ProgressContext* progress_ctx,
+      ImageCtxT** local_image_ctx,
+      std::string* local_image_id,
+      std::string* remote_mirror_uuid,
+      Journaler** remote_journaler,
+      bool* do_resync,
+      Context* on_finish);
   ~BootstrapRequest() override;
 
   bool is_syncing() const;
@@ -88,14 +89,22 @@ public:
   void send() override;
   void cancel() override;
 
+  std::string get_local_image_name() const;
+
 private:
   /**
    * @verbatim
    *
    * <start>
    *    |
-   *    v
-   * OPEN_REMOTE_IMAGE  * * * * * * * * * * * * * * * * * * * (error)
+   *    v                                           (error)
+   * PREPARE_LOCAL_IMAGE  * * * * * * * * * * * * * * * * * *
+   *    |                                                   *
+   *    v                                           (error) *
+   * PREPARE_REMOTE_IMAGE * * * * * * * * * * * * * * * * * *
+   *    |                                                   *
+   *    v                                           (error) *
+   * OPEN_REMOTE_IMAGE  * * * * * * * * * * * * * * * * * * *
    *    |                                                   *
    *    v                                                   *
    * GET_REMOTE_MIRROR_INFO * * * * * * * * * * * * * * *   *
@@ -135,16 +144,15 @@ private:
   librados::IoCtx &m_local_io_ctx;
   librados::IoCtx &m_remote_io_ctx;
   InstanceWatcher<ImageCtxT> *m_instance_watcher;
-  ImageCtxT **m_local_image_ctx;
-  std::string m_local_image_id;
   std::string m_remote_image_id;
   std::string m_global_image_id;
   std::string m_local_mirror_uuid;
-  std::string m_remote_mirror_uuid;
-  Journaler *m_remote_journaler;
-  cls::journal::ClientState *m_client_state;
-  MirrorPeerClientMeta *m_client_meta;
+  ::journal::CacheManagerHandler *m_cache_manager_handler;
   ProgressContext *m_progress_ctx;
+  ImageCtxT **m_local_image_ctx;
+  std::string* m_local_image_id;
+  std::string* m_remote_mirror_uuid;
+  Journaler** m_remote_journaler;
   bool *m_do_resync;
 
   mutable ceph::mutex m_lock;
@@ -156,9 +164,23 @@ private:
     librbd::mirror::PROMOTION_STATE_NON_PRIMARY;
   int m_ret_val = 0;
 
+  std::string m_local_image_name;
+  std::string m_local_image_tag_owner;
+  std::string m_prepare_local_image_name;
+
+  cls::journal::ClientState m_client_state =
+    cls::journal::CLIENT_STATE_DISCONNECTED;
+  librbd::journal::MirrorPeerClientMeta m_client_meta;
+
   bool m_syncing = false;
   ImageSync<ImageCtxT> *m_image_sync = nullptr;
 
+  void prepare_local_image();
+  void handle_prepare_local_image(int r);
+
+  void prepare_remote_image();
+  void handle_prepare_remote_image(int r);
+
   void open_remote_image();
   void handle_open_remote_image(int r);
 
diff --git a/src/tools/rbd_mirror/image_replayer/PrepareLocalImageRequest.cc b/src/tools/rbd_mirror/image_replayer/PrepareLocalImageRequest.cc
index 8e0ea8373d9..37e6bf4b744 100644
--- a/src/tools/rbd_mirror/image_replayer/PrepareLocalImageRequest.cc
+++ b/src/tools/rbd_mirror/image_replayer/PrepareLocalImageRequest.cc
@@ -29,13 +29,13 @@ using librbd::util::create_rados_callback;
 
 template <typename I>
 void PrepareLocalImageRequest<I>::send() {
-  dout(20) << dendl;
+  dout(10) << dendl;
   get_local_image_id();
 }
 
 template <typename I>
 void PrepareLocalImageRequest<I>::get_local_image_id() {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   Context *ctx = create_context_callback<
     PrepareLocalImageRequest<I>,
@@ -47,7 +47,7 @@ void PrepareLocalImageRequest<I>::get_local_image_id() {
 
 template <typename I>
 void PrepareLocalImageRequest<I>::handle_get_local_image_id(int r) {
-  dout(20) << "r=" << r << ", "
+  dout(10) << "r=" << r << ", "
            << "local_image_id=" << *m_local_image_id << dendl;
 
   if (r < 0) {
@@ -60,7 +60,7 @@ void PrepareLocalImageRequest<I>::handle_get_local_image_id(int r) {
 
 template <typename I>
 void PrepareLocalImageRequest<I>::get_local_image_name() {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   librados::ObjectReadOperation op;
   librbd::cls_client::dir_get_name_start(&op, *m_local_image_id);
@@ -76,7 +76,7 @@ void PrepareLocalImageRequest<I>::get_local_image_name() {
 
 template <typename I>
 void PrepareLocalImageRequest<I>::handle_get_local_image_name(int r) {
-  dout(20) << "r=" << r << dendl;
+  dout(10) << "r=" << r << dendl;
 
   if (r == 0) {
     auto it = m_out_bl.cbegin();
@@ -96,7 +96,7 @@ void PrepareLocalImageRequest<I>::handle_get_local_image_name(int r) {
 
 template <typename I>
 void PrepareLocalImageRequest<I>::get_mirror_state() {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   librados::ObjectReadOperation op;
   librbd::cls_client::mirror_image_get_start(&op, *m_local_image_id);
@@ -112,7 +112,7 @@ void PrepareLocalImageRequest<I>::get_mirror_state() {
 
 template <typename I>
 void PrepareLocalImageRequest<I>::handle_get_mirror_state(int r) {
-  dout(20) << ": r=" << r << dendl;
+  dout(10) << ": r=" << r << dendl;
 
   cls::rbd::MirrorImage mirror_image;
   if (r == 0) {
@@ -141,7 +141,7 @@ void PrepareLocalImageRequest<I>::get_tag_owner() {
     typename std::remove_pointer<decltype(std::declval<I>().journal)>
     ::type>::type;
 
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   Context *ctx = create_context_callback<
     PrepareLocalImageRequest<I>,
@@ -152,7 +152,7 @@ void PrepareLocalImageRequest<I>::get_tag_owner() {
 
 template <typename I>
 void PrepareLocalImageRequest<I>::handle_get_tag_owner(int r) {
-  dout(20) << "r=" << r << ", "
+  dout(10) << "r=" << r << ", "
            << "tag_owner=" << *m_tag_owner << dendl;
 
   if (r < 0) {
@@ -167,7 +167,7 @@ void PrepareLocalImageRequest<I>::handle_get_tag_owner(int r) {
 
 template <typename I>
 void PrepareLocalImageRequest<I>::finish(int r) {
-  dout(20) << "r=" << r << dendl;
+  dout(10) << "r=" << r << dendl;
 
   m_on_finish->complete(r);
   delete this;
diff --git a/src/tools/rbd_mirror/image_replayer/PrepareRemoteImageRequest.cc b/src/tools/rbd_mirror/image_replayer/PrepareRemoteImageRequest.cc
index e89ab6dfaf3..ebc2ca4256e 100644
--- a/src/tools/rbd_mirror/image_replayer/PrepareRemoteImageRequest.cc
+++ b/src/tools/rbd_mirror/image_replayer/PrepareRemoteImageRequest.cc
@@ -37,7 +37,7 @@ void PrepareRemoteImageRequest<I>::send() {
 
 template <typename I>
 void PrepareRemoteImageRequest<I>::get_remote_mirror_uuid() {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   librados::ObjectReadOperation op;
   librbd::cls_client::mirror_uuid_get_start(&op);
@@ -60,7 +60,7 @@ void PrepareRemoteImageRequest<I>::handle_get_remote_mirror_uuid(int r) {
     }
   }
 
-  dout(20) << "r=" << r << dendl;
+  dout(10) << "r=" << r << dendl;
   if (r < 0) {
     if (r == -ENOENT) {
       dout(5) << "remote mirror uuid missing" << dendl;
@@ -77,7 +77,7 @@ void PrepareRemoteImageRequest<I>::handle_get_remote_mirror_uuid(int r) {
 
 template <typename I>
 void PrepareRemoteImageRequest<I>::get_remote_image_id() {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   Context *ctx = create_context_callback<
     PrepareRemoteImageRequest<I>,
@@ -90,7 +90,7 @@ void PrepareRemoteImageRequest<I>::get_remote_image_id() {
 
 template <typename I>
 void PrepareRemoteImageRequest<I>::handle_get_remote_image_id(int r) {
-  dout(20) << "r=" << r << ", "
+  dout(10) << "r=" << r << ", "
            << "remote_image_id=" << *m_remote_image_id << dendl;
 
   if (r < 0) {
@@ -103,7 +103,7 @@ void PrepareRemoteImageRequest<I>::handle_get_remote_image_id(int r) {
 
 template <typename I>
 void PrepareRemoteImageRequest<I>::get_client() {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   ceph_assert(*m_remote_journaler == nullptr);
   *m_remote_journaler = new Journaler(m_threads->work_queue, m_threads->timer,
@@ -121,7 +121,7 @@ void PrepareRemoteImageRequest<I>::get_client() {
 
 template <typename I>
 void PrepareRemoteImageRequest<I>::handle_get_client(int r) {
-  dout(20) << "r=" << r << dendl;
+  dout(10) << "r=" << r << dendl;
 
   if (r == -ENOENT) {
     dout(10) << "client not registered" << dendl;
@@ -141,7 +141,7 @@ void PrepareRemoteImageRequest<I>::handle_get_client(int r) {
 
 template <typename I>
 void PrepareRemoteImageRequest<I>::register_client() {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   librbd::journal::MirrorPeerClientMeta mirror_peer_client_meta{
     m_local_image_id};
@@ -160,7 +160,7 @@ void PrepareRemoteImageRequest<I>::register_client() {
 
 template <typename I>
 void PrepareRemoteImageRequest<I>::handle_register_client(int r) {
-  dout(20) << "r=" << r << dendl;
+  dout(10) << "r=" << r << dendl;
 
   if (r < 0) {
     derr << "failed to register with remote journal: " << cpp_strerror(r)
@@ -178,7 +178,7 @@ void PrepareRemoteImageRequest<I>::handle_register_client(int r) {
 
 template <typename I>
 void PrepareRemoteImageRequest<I>::finish(int r) {
-  dout(20) << "r=" << r << dendl;
+  dout(10) << "r=" << r << dendl;
 
   if (r < 0) {
     delete *m_remote_journaler;