rbd-mirror: move state machine transition debug messages to higher priority

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

diff --git a/src/tools/rbd_mirror/ImageReplayer.cc b/src/tools/rbd_mirror/ImageReplayer.cc
index 6acf011cc9ebbb9834f67689f7e4cb5cc0711b40..3af0e3a0d5c5bd01aa18f91f1fd9d7877d4b0483 100644 (file)
--- a/src/tools/rbd_mirror/ImageReplayer.cc
+++ b/src/tools/rbd_mirror/ImageReplayer.cc
@@ -396,7 +396,7 @@ void ImageReplayer<I>::start(Context *on_finish, bool manual)
 
 template <typename I>
 void ImageReplayer<I>::prepare_local_image() {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   m_local_image_id = "";
   Context *ctx = create_context_callback<
@@ -409,10 +409,10 @@ void ImageReplayer<I>::prepare_local_image() {
 
 template <typename I>
 void ImageReplayer<I>::handle_prepare_local_image(int r) {
-  dout(20) << "r=" << r << dendl;
+  dout(10) << "r=" << r << dendl;
 
   if (r == -ENOENT) {
-    dout(20) << "local image does not exist" << dendl;
+    dout(10) << "local image does not exist" << dendl;
   } else if (r < 0) {
     on_start_fail(r, "error preparing local image for replay");
     return;
@@ -426,7 +426,7 @@ void ImageReplayer<I>::handle_prepare_local_image(int r) {
 
 template <typename I>
 void ImageReplayer<I>::prepare_remote_image() {
-  dout(20) << dendl;
+  dout(10) << dendl;
   if (m_peers.empty()) {
     // technically nothing to bootstrap, but it handles the status update
     bootstrap();
@@ -448,14 +448,14 @@ void ImageReplayer<I>::prepare_remote_image() {
 
 template <typename I>
 void ImageReplayer<I>::handle_prepare_remote_image(int r) {
-  dout(20) << "r=" << r << dendl;
+  dout(10) << "r=" << r << dendl;
 
   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(20) << "remote image does not exist" << dendl;
+    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() &&
@@ -479,7 +479,7 @@ void ImageReplayer<I>::handle_prepare_remote_image(int r) {
 
 template <typename I>
 void ImageReplayer<I>::bootstrap() {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   if (!m_local_image_id.empty() &&
       m_local_image_tag_owner == librbd::Journal<>::LOCAL_MIRROR_UUID) {
@@ -517,7 +517,7 @@ void ImageReplayer<I>::bootstrap() {
 
 template <typename I>
 void ImageReplayer<I>::handle_bootstrap(int r) {
-  dout(20) << "r=" << r << dendl;
+  dout(10) << "r=" << r << dendl;
   {
     Mutex::Locker locker(m_lock);
     m_bootstrap_request->put();
@@ -566,7 +566,7 @@ void ImageReplayer<I>::handle_bootstrap(int r) {
 
 template <typename I>
 void ImageReplayer<I>::init_remote_journaler() {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   Context *ctx = create_context_callback<
     ImageReplayer, &ImageReplayer<I>::handle_init_remote_journaler>(this);
@@ -575,7 +575,7 @@ void ImageReplayer<I>::init_remote_journaler() {
 
 template <typename I>
 void ImageReplayer<I>::handle_init_remote_journaler(int r) {
-  dout(20) << "r=" << r << dendl;
+  dout(10) << "r=" << r << dendl;
 
   if (r < 0) {
     derr << "failed to initialize remote journal: " << cpp_strerror(r) << dendl;
@@ -616,7 +616,7 @@ void ImageReplayer<I>::handle_init_remote_journaler(int r) {
 
 template <typename I>
 void ImageReplayer<I>::start_replay() {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   Context *start_ctx = create_context_callback<
     ImageReplayer, &ImageReplayer<I>::handle_start_replay>(this);
@@ -625,7 +625,7 @@ void ImageReplayer<I>::start_replay() {
 
 template <typename I>
 void ImageReplayer<I>::handle_start_replay(int r) {
-  dout(20) << "r=" << r << dendl;
+  dout(10) << "r=" << r << dendl;
 
   if (r < 0) {
     assert(m_local_replay == nullptr);
@@ -665,7 +665,7 @@ void ImageReplayer<I>::handle_start_replay(int r) {
     m_replay_handler = new ReplayHandler<I>(this);
     m_remote_journaler->start_live_replay(m_replay_handler, poll_seconds);
 
-    dout(20) << "m_remote_journaler=" << *m_remote_journaler << dendl;
+    dout(10) << "m_remote_journaler=" << *m_remote_journaler << dendl;
   }
 
   dout(20) << "start succeeded" << dendl;
@@ -1025,7 +1025,7 @@ void ImageReplayer<I>::handle_replay_flush(int r) {
 
 template <typename I>
 void ImageReplayer<I>::get_remote_tag() {
-  dout(20) << "tag_tid: " << m_replay_tag_tid << dendl;
+  dout(15) << "tag_tid: " << m_replay_tag_tid << dendl;
 
   Context *ctx = create_context_callback<
     ImageReplayer, &ImageReplayer<I>::handle_get_remote_tag>(this);
@@ -1034,7 +1034,7 @@ void ImageReplayer<I>::get_remote_tag() {
 
 template <typename I>
 void ImageReplayer<I>::handle_get_remote_tag(int r) {
-  dout(20) << "r=" << r << dendl;
+  dout(15) << "r=" << r << dendl;
 
   if (r == 0) {
     try {
@@ -1054,7 +1054,7 @@ void ImageReplayer<I>::handle_get_remote_tag(int r) {
   }
 
   m_replay_tag_valid = true;
-  dout(20) << "decoded remote tag " << m_replay_tag_tid << ": "
+  dout(15) << "decoded remote tag " << m_replay_tag_tid << ": "
            << m_replay_tag_data << dendl;
 
   allocate_local_tag();
@@ -1417,7 +1417,7 @@ void ImageReplayer<I>::send_mirror_status_update(const OptionalState &opt_state)
     status.state = *mirror_image_status_state;
   }
 
-  dout(20) << "status=" << status << dendl;
+  dout(15) << "status=" << status << dendl;
   librados::ObjectWriteOperation op;
   librbd::cls_client::mirror_image_status_set(&op, m_global_image_id, status);
 
@@ -1430,7 +1430,7 @@ void ImageReplayer<I>::send_mirror_status_update(const OptionalState &opt_state)
 
 template <typename I>
 void ImageReplayer<I>::handle_mirror_status_update(int r) {
-  dout(20) << "r=" << r << dendl;
+  dout(15) << "r=" << r << dendl;
 
   bool running = false;
   bool started = false;
@@ -1498,7 +1498,7 @@ void ImageReplayer<I>::reschedule_update_status_task(int new_interval) {
 
 template <typename I>
 void ImageReplayer<I>::shut_down(int r) {
-  dout(20) << "r=" << r << dendl;
+  dout(10) << "r=" << r << dendl;
 
   bool canceled_delayed_preprocess_task = false;
   {
@@ -1677,7 +1677,7 @@ void ImageReplayer<I>::handle_shut_down(int r) {
     return;
   }
 
-  dout(20) << "stop complete" << dendl;
+  dout(10) << "stop complete" << dendl;
   ReplayStatusFormatter<I>::destroy(m_replay_status_formatter);
   m_replay_status_formatter = nullptr;
 

diff --git a/src/tools/rbd_mirror/ImageSync.cc b/src/tools/rbd_mirror/ImageSync.cc
index 60132c2fe094c2a2af5a73e9a986d07f31271fdc..3e09c12d5d2a2e9dd81fc67239baaa737b0d9b21 100644 (file)
--- a/src/tools/rbd_mirror/ImageSync.cc
+++ b/src/tools/rbd_mirror/ImageSync.cc
@@ -79,7 +79,7 @@ template <typename I>
 void ImageSync<I>::cancel() {
   Mutex::Locker locker(m_lock);
 
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   m_canceled = true;
 
@@ -96,7 +96,7 @@ template <typename I>
 void ImageSync<I>::send_notify_sync_request() {
   update_progress("NOTIFY_SYNC_REQUEST");
 
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   Context *ctx = create_context_callback<
     ImageSync<I>, &ImageSync<I>::handle_notify_sync_request>(this);
@@ -105,7 +105,7 @@ void ImageSync<I>::send_notify_sync_request() {
 
 template <typename I>
 void ImageSync<I>::handle_notify_sync_request(int r) {
-  dout(20) << ": r=" << r << dendl;
+  dout(10) << ": r=" << r << dendl;
 
   if (r < 0) {
     BaseRequest::finish(r);
@@ -124,7 +124,7 @@ void ImageSync<I>::send_prune_catch_up_sync_point() {
     return;
   }
 
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   // prune will remove sync points with missing snapshots and
   // ensure we have a maximum of one sync point (in case we
@@ -138,7 +138,7 @@ void ImageSync<I>::send_prune_catch_up_sync_point() {
 
 template <typename I>
 void ImageSync<I>::handle_prune_catch_up_sync_point(int r) {
-  dout(20) << ": r=" << r << dendl;
+  dout(10) << ": r=" << r << dendl;
 
   if (r < 0) {
     derr << ": failed to prune catch-up sync point: "
@@ -161,7 +161,7 @@ void ImageSync<I>::send_create_sync_point() {
     return;
   }
 
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   Context *ctx = create_context_callback<
     ImageSync<I>, &ImageSync<I>::handle_create_sync_point>(this);
@@ -172,7 +172,7 @@ void ImageSync<I>::send_create_sync_point() {
 
 template <typename I>
 void ImageSync<I>::handle_create_sync_point(int r) {
-  dout(20) << ": r=" << r << dendl;
+  dout(10) << ": r=" << r << dendl;
 
   if (r < 0) {
     derr << ": failed to create sync point: " << cpp_strerror(r)
@@ -222,7 +222,7 @@ void ImageSync<I>::send_copy_image() {
     return;
   }
 
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   Context *ctx = create_context_callback<
     ImageSync<I>, &ImageSync<I>::handle_copy_image>(this);
@@ -241,7 +241,7 @@ void ImageSync<I>::send_copy_image() {
 
 template <typename I>
 void ImageSync<I>::handle_copy_image(int r) {
-  dout(20) << ": r=" << r << dendl;
+  dout(10) << ": r=" << r << dendl;
 
   {
     Mutex::Locker timer_locker(*m_timer_lock);
@@ -382,7 +382,7 @@ void ImageSync<I>::send_flush_sync_point() {
     sync_point->object_number = boost::none;
   }
 
-  dout(20) << ": sync_point=" << *sync_point << dendl;
+  dout(10) << ": sync_point=" << *sync_point << dendl;
 
   bufferlist client_data_bl;
   librbd::journal::ClientData client_data(*m_client_meta);
@@ -396,7 +396,7 @@ void ImageSync<I>::send_flush_sync_point() {
 
 template <typename I>
 void ImageSync<I>::handle_flush_sync_point(int r) {
-  dout(20) << ": r=" << r << dendl;
+  dout(10) << ": r=" << r << dendl;
 
   if (r < 0) {
     *m_client_meta = m_client_meta_copy;
@@ -412,7 +412,7 @@ void ImageSync<I>::handle_flush_sync_point(int r) {
 
 template <typename I>
 void ImageSync<I>::send_prune_sync_points() {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   update_progress("PRUNE_SYNC_POINTS");
 
@@ -425,7 +425,7 @@ void ImageSync<I>::send_prune_sync_points() {
 
 template <typename I>
 void ImageSync<I>::handle_prune_sync_points(int r) {
-  dout(20) << ": r=" << r << dendl;
+  dout(10) << ": r=" << r << dendl;
 
   if (r < 0) {
     derr << ": failed to prune sync point: "

diff --git a/src/tools/rbd_mirror/InstanceReplayer.cc b/src/tools/rbd_mirror/InstanceReplayer.cc
index d08f54d8aa47a5c3c5318ff0f62fa7d6cb030dea..95307b8291be30d3b1f22c35477dbf78059b177c 100644 (file)
--- a/src/tools/rbd_mirror/InstanceReplayer.cc
+++ b/src/tools/rbd_mirror/InstanceReplayer.cc
@@ -58,7 +58,7 @@ int InstanceReplayer<I>::init() {
 
 template <typename I>
 void InstanceReplayer<I>::init(Context *on_finish) {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   Context *ctx = new FunctionContext(
     [this, on_finish] (int r) {
@@ -82,7 +82,7 @@ void InstanceReplayer<I>::shut_down() {
 
 template <typename I>
 void InstanceReplayer<I>::shut_down(Context *on_finish) {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   Mutex::Locker locker(m_lock);
 
@@ -101,7 +101,7 @@ void InstanceReplayer<I>::shut_down(Context *on_finish) {
 template <typename I>
 void InstanceReplayer<I>::add_peer(std::string peer_uuid,
                                    librados::IoCtx io_ctx) {
-  dout(20) << peer_uuid << dendl;
+  dout(10) << peer_uuid << dendl;
 
   Mutex::Locker locker(m_lock);
   auto result = m_peers.insert(Peer(peer_uuid, io_ctx)).second;
@@ -110,7 +110,7 @@ void InstanceReplayer<I>::add_peer(std::string peer_uuid,
 
 template <typename I>
 void InstanceReplayer<I>::release_all(Context *on_finish) {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   Mutex::Locker locker(m_lock);
 
@@ -133,7 +133,7 @@ template <typename I>
 void InstanceReplayer<I>::acquire_image(InstanceWatcher<I> *instance_watcher,
                                         const std::string &global_image_id,
                                         Context *on_finish) {
-  dout(20) << "global_image_id=" << global_image_id << dendl;
+  dout(10) << "global_image_id=" << global_image_id << dendl;
 
   Mutex::Locker locker(m_lock);
 
@@ -145,7 +145,7 @@ void InstanceReplayer<I>::acquire_image(InstanceWatcher<I> *instance_watcher,
         m_threads, instance_watcher, m_local_rados,
         m_local_mirror_uuid, m_local_pool_id, global_image_id);
 
-    dout(20) << global_image_id << ": creating replayer " << image_replayer
+    dout(10) << global_image_id << ": creating replayer " << image_replayer
              << dendl;
 
     it = m_image_replayers.insert(std::make_pair(global_image_id,
@@ -168,14 +168,14 @@ void InstanceReplayer<I>::acquire_image(InstanceWatcher<I> *instance_watcher,
 template <typename I>
 void InstanceReplayer<I>::release_image(const std::string &global_image_id,
                                         Context *on_finish) {
-  dout(20) << "global_image_id=" << global_image_id << dendl;
+  dout(10) << "global_image_id=" << global_image_id << dendl;
 
   Mutex::Locker locker(m_lock);
   assert(m_on_shut_down == nullptr);
 
   auto it = m_image_replayers.find(global_image_id);
   if (it == m_image_replayers.end()) {
-    dout(20) << global_image_id << ": not found" << dendl;
+    dout(5) << global_image_id << ": not found" << dendl;
     m_threads->work_queue->queue(on_finish, 0);
     return;
   }
@@ -195,7 +195,7 @@ template <typename I>
 void InstanceReplayer<I>::remove_peer_image(const std::string &global_image_id,
                                             const std::string &peer_mirror_uuid,
                                             Context *on_finish) {
-  dout(20) << "global_image_id=" << global_image_id << ", "
+  dout(10) << "global_image_id=" << global_image_id << ", "
            << "peer_mirror_uuid=" << peer_mirror_uuid << dendl;
 
   Mutex::Locker locker(m_lock);
@@ -215,7 +215,7 @@ void InstanceReplayer<I>::remove_peer_image(const std::string &global_image_id,
 
 template <typename I>
 void InstanceReplayer<I>::print_status(Formatter *f, stringstream *ss) {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   if (!f) {
     return;
@@ -234,7 +234,7 @@ void InstanceReplayer<I>::print_status(Formatter *f, stringstream *ss) {
 template <typename I>
 void InstanceReplayer<I>::start()
 {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   Mutex::Locker locker(m_lock);
 
@@ -249,7 +249,7 @@ void InstanceReplayer<I>::start()
 template <typename I>
 void InstanceReplayer<I>::stop()
 {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   Mutex::Locker locker(m_lock);
 
@@ -264,7 +264,7 @@ void InstanceReplayer<I>::stop()
 template <typename I>
 void InstanceReplayer<I>::restart()
 {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   Mutex::Locker locker(m_lock);
 
@@ -279,7 +279,7 @@ void InstanceReplayer<I>::restart()
 template <typename I>
 void InstanceReplayer<I>::flush()
 {
-  dout(20) << "enter" << dendl;
+  dout(10) << dendl;
 
   Mutex::Locker locker(m_lock);
 
@@ -295,7 +295,7 @@ void InstanceReplayer<I>::start_image_replayer(
   assert(m_lock.is_locked());
 
   std::string global_image_id = image_replayer->get_global_image_id();
-  dout(20) << "global_image_id=" << global_image_id << dendl;
+  dout(10) << "global_image_id=" << global_image_id << dendl;
 
   if (!image_replayer->is_stopped()) {
     return;
@@ -316,7 +316,7 @@ void InstanceReplayer<I>::start_image_replayer(
 
 template <typename I>
 void InstanceReplayer<I>::queue_start_image_replayers() {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   Context *ctx = create_context_callback<
     InstanceReplayer, &InstanceReplayer<I>::start_image_replayers>(this);
@@ -326,7 +326,7 @@ void InstanceReplayer<I>::queue_start_image_replayers() {
 
 template <typename I>
 void InstanceReplayer<I>::start_image_replayers(int r) {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   Mutex::Locker locker(m_lock);
   if (m_on_shut_down != nullptr) {
@@ -365,7 +365,7 @@ void InstanceReplayer<I>::start_image_replayers(int r) {
 template <typename I>
 void InstanceReplayer<I>::stop_image_replayer(ImageReplayer<I> *image_replayer,
                                               Context *on_finish) {
-  dout(20) << image_replayer << " global_image_id="
+  dout(10) << image_replayer << " global_image_id="
            << image_replayer->get_global_image_id() << ", on_finish="
            << on_finish << dendl;
 
@@ -386,7 +386,7 @@ void InstanceReplayer<I>::stop_image_replayer(ImageReplayer<I> *image_replayer,
     image_replayer->stop(ctx, false);
   } else {
     int after = 1;
-    dout(20) << "scheduling image replayer " << image_replayer << " stop after "
+    dout(10) << "scheduling image replayer " << image_replayer << " stop after "
              << after << " sec (task " << ctx << ")" << dendl;
     ctx = new FunctionContext(
       [this, after, ctx] (int r) {
@@ -399,7 +399,7 @@ void InstanceReplayer<I>::stop_image_replayer(ImageReplayer<I> *image_replayer,
 
 template <typename I>
 void InstanceReplayer<I>::wait_for_ops() {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   Context *ctx = create_context_callback<
     InstanceReplayer, &InstanceReplayer<I>::handle_wait_for_ops>(this);
@@ -409,7 +409,7 @@ void InstanceReplayer<I>::wait_for_ops() {
 
 template <typename I>
 void InstanceReplayer<I>::handle_wait_for_ops(int r) {
-  dout(20) << "r=" << r << dendl;
+  dout(10) << "r=" << r << dendl;
 
   assert(r == 0);
 
@@ -419,7 +419,7 @@ void InstanceReplayer<I>::handle_wait_for_ops(int r) {
 
 template <typename I>
 void InstanceReplayer<I>::stop_image_replayers() {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   assert(m_lock.is_locked());
 
@@ -436,7 +436,7 @@ void InstanceReplayer<I>::stop_image_replayers() {
 
 template <typename I>
 void InstanceReplayer<I>::handle_stop_image_replayers(int r) {
-  dout(20) << "r=" << r << dendl;
+  dout(10) << "r=" << r << dendl;
 
   assert(r == 0);
 
@@ -464,7 +464,7 @@ void InstanceReplayer<I>::cancel_image_state_check_task() {
     return;
   }
 
-  dout(20) << m_image_state_check_task << dendl;
+  dout(10) << m_image_state_check_task << dendl;
   bool canceled = m_threads->timer->cancel_event(m_image_state_check_task);
   assert(canceled);
   m_image_state_check_task = nullptr;
@@ -486,7 +486,7 @@ void InstanceReplayer<I>::schedule_image_state_check_task() {
   int after = g_ceph_context->_conf->get_val<int64_t>(
     "rbd_mirror_image_state_check_interval");
 
-  dout(20) << "scheduling image state check after " << after << " sec (task "
+  dout(10) << "scheduling image state check after " << after << " sec (task "
            << m_image_state_check_task << ")" << dendl;
   m_threads->timer->add_event_after(after, m_image_state_check_task);
 }

diff --git a/src/tools/rbd_mirror/InstanceWatcher.cc b/src/tools/rbd_mirror/InstanceWatcher.cc
index 42d0d7abddcb244bd677b4e19c3e4419b00dc2d6..796b7bfe604c727fe65c69c2c2c5171eff538cce 100644 (file)
--- a/src/tools/rbd_mirror/InstanceWatcher.cc
+++ b/src/tools/rbd_mirror/InstanceWatcher.cc
@@ -38,7 +38,7 @@ struct C_GetInstances : public Context {
   }
 
   void finish(int r) override {
-    dout(20) << "C_GetInstances: " << this << " " <<  __func__ << ": r=" << r
+    dout(10) << "C_GetInstances: " << this << " " <<  __func__ << ": r=" << r
              << dendl;
 
     if (r == 0) {
@@ -63,13 +63,13 @@ struct C_RemoveInstanceRequest : public Context {
   }
 
   void send() {
-    dout(20) << "C_RemoveInstanceRequest: " << this << " " << __func__ << dendl;
+    dout(10) << "C_RemoveInstanceRequest: " << this << " " << __func__ << dendl;
 
     instance_watcher.remove(this);
   }
 
   void finish(int r) override {
-    dout(20) << "C_RemoveInstanceRequest: " << this << " " << __func__ << ": r="
+    dout(10) << "C_RemoveInstanceRequest: " << this << " " << __func__ << ": r="
              << r << dendl;
     assert(r == 0);
 
@@ -97,7 +97,7 @@ struct InstanceWatcher<I>::C_NotifyInstanceRequest : public Context {
     : instance_watcher(instance_watcher), instance_id(instance_id),
       request_id(request_id), bl(bl), on_finish(on_finish),
       send_to_leader(instance_id.empty()) {
-    dout(20) << "C_NotifyInstanceRequest: " << this << " " << __func__
+    dout(10) << "C_NotifyInstanceRequest: " << this << " " << __func__
              << ": instance_watcher=" << instance_watcher << ", instance_id="
              << instance_id << ", request_id=" << request_id << dendl;
 
@@ -118,12 +118,12 @@ struct InstanceWatcher<I>::C_NotifyInstanceRequest : public Context {
   }
 
   void send() {
-    dout(20) << "C_NotifyInstanceRequest: " << this << " " << __func__ << dendl;
+    dout(10) << "C_NotifyInstanceRequest: " << this << " " << __func__ << dendl;
 
     assert(instance_watcher->m_lock.is_locked());
 
     if (canceling) {
-      dout(20) << "C_NotifyInstanceRequest: " << this << " " << __func__
+      dout(10) << "C_NotifyInstanceRequest: " << this << " " << __func__
                << ": canceling" << dendl;
       instance_watcher->m_work_queue->queue(this, -ECANCELED);
       return;
@@ -131,7 +131,7 @@ struct InstanceWatcher<I>::C_NotifyInstanceRequest : public Context {
 
     if (send_to_leader) {
       if (instance_watcher->m_leader_instance_id.empty()) {
-        dout(20) << "C_NotifyInstanceRequest: " << this << " " << __func__
+        dout(10) << "C_NotifyInstanceRequest: " << this << " " << __func__
                  << ": suspending" << dendl;
         instance_watcher->suspend_notify_request(this);
         return;
@@ -155,13 +155,13 @@ struct InstanceWatcher<I>::C_NotifyInstanceRequest : public Context {
       }
     }
 
-    dout(20) << "C_NotifyInstanceRequest: " << this << " " << __func__
+    dout(10) << "C_NotifyInstanceRequest: " << this << " " << __func__
              << ": sending to " << instance_id << dendl;
     notifier->notify(bl, &response, this);
   }
 
   void cancel() {
-    dout(20) << "C_NotifyInstanceRequest: " << this << " " << __func__ << dendl;
+    dout(10) << "C_NotifyInstanceRequest: " << this << " " << __func__ << dendl;
 
     assert(instance_watcher->m_lock.is_locked());
 
@@ -170,7 +170,7 @@ struct InstanceWatcher<I>::C_NotifyInstanceRequest : public Context {
   }
 
   void finish(int r) override {
-    dout(20) << "C_NotifyInstanceRequest: " << this << " " << __func__ << ": r="
+    dout(10) << "C_NotifyInstanceRequest: " << this << " " << __func__ << ": r="
              << r << dendl;
 
     if (r == 0 || r == -ETIMEDOUT) {
@@ -178,8 +178,8 @@ struct InstanceWatcher<I>::C_NotifyInstanceRequest : public Context {
       for (auto &it : response.acks) {
         auto &bl = it.second;
         if (it.second.length() == 0) {
-          dout(20) << "C_NotifyInstanceRequest: " << this << " " << __func__
-                   << ": no payload in ack, ignoring" << dendl;
+          dout(5) << "C_NotifyInstanceRequest: " << this << " " << __func__
+                  << ": no payload in ack, ignoring" << dendl;
           continue;
         }
         try {
@@ -259,12 +259,12 @@ struct InstanceWatcher<I>::C_SyncRequest : public Context {
                 const std::string &sync_id, Context *on_start)
     : instance_watcher(instance_watcher), sync_id(sync_id),
       on_start(on_start) {
-    dout(20) << "C_SyncRequest: " << this << " " << __func__ << ": sync_id="
+    dout(10) << "C_SyncRequest: " << this << " " << __func__ << ": sync_id="
              << sync_id << dendl;
   }
 
   void finish(int r) override {
-    dout(20) << "C_SyncRequest: " << this << " " << __func__ << ": r="
+    dout(10) << "C_SyncRequest: " << this << " " << __func__ << ": r="
              << r << dendl;
 
     if (on_start != nullptr) {
@@ -348,7 +348,7 @@ int InstanceWatcher<I>::init() {
 
 template <typename I>
 void InstanceWatcher<I>::init(Context *on_finish) {
-  dout(20) << "instance_id=" << m_instance_id << dendl;
+  dout(10) << "instance_id=" << m_instance_id << dendl;
 
   Mutex::Locker locker(m_lock);
 
@@ -369,7 +369,7 @@ void InstanceWatcher<I>::shut_down() {
 
 template <typename I>
 void InstanceWatcher<I>::shut_down(Context *on_finish) {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   Mutex::Locker locker(m_lock);
 
@@ -382,7 +382,7 @@ void InstanceWatcher<I>::shut_down(Context *on_finish) {
 
 template <typename I>
 void InstanceWatcher<I>::remove(Context *on_finish) {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   Mutex::Locker locker(m_lock);
 
@@ -398,7 +398,7 @@ template <typename I>
 void InstanceWatcher<I>::notify_image_acquire(
     const std::string &instance_id, const std::string &global_image_id,
     Context *on_notify_ack) {
-  dout(20) << "instance_id=" << instance_id << ", global_image_id="
+  dout(10) << "instance_id=" << instance_id << ", global_image_id="
            << global_image_id << dendl;
 
   Mutex::Locker locker(m_lock);
@@ -422,7 +422,7 @@ template <typename I>
 void InstanceWatcher<I>::notify_image_release(
     const std::string &instance_id, const std::string &global_image_id,
     Context *on_notify_ack) {
-  dout(20) << "instance_id=" << instance_id << ", global_image_id="
+  dout(10) << "instance_id=" << instance_id << ", global_image_id="
            << global_image_id << dendl;
 
   Mutex::Locker locker(m_lock);
@@ -446,7 +446,7 @@ template <typename I>
 void InstanceWatcher<I>::notify_peer_image_removed(
     const std::string &instance_id, const std::string &global_image_id,
     const std::string &peer_mirror_uuid, Context *on_notify_ack) {
-  dout(20) << "instance_id=" << instance_id << ", "
+  dout(10) << "instance_id=" << instance_id << ", "
            << "global_image_id=" << global_image_id << ", "
            << "peer_mirror_uuid=" << peer_mirror_uuid << dendl;
 
@@ -469,7 +469,7 @@ void InstanceWatcher<I>::notify_peer_image_removed(
 template <typename I>
 void InstanceWatcher<I>::notify_sync_request(const std::string &sync_id,
                                              Context *on_sync_start) {
-  dout(20) << "sync_id=" << sync_id << dendl;
+  dout(10) << "sync_id=" << sync_id << dendl;
 
   Mutex::Locker locker(m_lock);
 
@@ -490,7 +490,7 @@ void InstanceWatcher<I>::notify_sync_request(const std::string &sync_id,
 
 template <typename I>
 bool InstanceWatcher<I>::cancel_sync_request(const std::string &sync_id) {
-  dout(20) << "sync_id=" << sync_id << dendl;
+  dout(10) << "sync_id=" << sync_id << dendl;
 
   Mutex::Locker locker(m_lock);
 
@@ -513,7 +513,7 @@ bool InstanceWatcher<I>::cancel_sync_request(const std::string &sync_id) {
 template <typename I>
 void InstanceWatcher<I>::notify_sync_start(const std::string &instance_id,
                                            const std::string &sync_id) {
-  dout(20) << "sync_id=" << sync_id << dendl;
+  dout(10) << "sync_id=" << sync_id << dendl;
 
   Mutex::Locker locker(m_lock);
 
@@ -524,7 +524,7 @@ void InstanceWatcher<I>::notify_sync_start(const std::string &instance_id,
 
   auto ctx = new FunctionContext(
     [this, sync_id] (int r) {
-      dout(20) << "finish: sync_id=" << sync_id << ", r=" << r << dendl;
+      dout(10) << "finish: sync_id=" << sync_id << ", r=" << r << dendl;
       Mutex::Locker locker(m_lock);
       if (r != -ESTALE && m_image_sync_throttler != nullptr) {
         m_image_sync_throttler->finish_op(sync_id);
@@ -537,7 +537,7 @@ void InstanceWatcher<I>::notify_sync_start(const std::string &instance_id,
 
 template <typename I>
 void InstanceWatcher<I>::notify_sync_complete(const std::string &sync_id) {
-  dout(20) << "sync_id=" << sync_id << dendl;
+  dout(10) << "sync_id=" << sync_id << dendl;
 
   Mutex::Locker locker(m_lock);
 
@@ -554,7 +554,7 @@ void InstanceWatcher<I>::notify_sync_complete(const std::string &sync_id) {
 template <typename I>
 void InstanceWatcher<I>::handle_notify_sync_request(C_SyncRequest *sync_ctx,
                                                     int r) {
-  dout(20) << "sync_id=" << sync_ctx->sync_id << ", r=" << r << dendl;
+  dout(10) << "sync_id=" << sync_ctx->sync_id << ", r=" << r << dendl;
 
   Context *on_start = nullptr;
   {
@@ -581,7 +581,7 @@ void InstanceWatcher<I>::handle_notify_sync_request(C_SyncRequest *sync_ctx,
 template <typename I>
 void InstanceWatcher<I>::handle_notify_sync_complete(C_SyncRequest *sync_ctx,
                                                      int r) {
-  dout(20) << "sync_id=" << sync_ctx->sync_id << ", r=" << r << dendl;
+  dout(10) << "sync_id=" << sync_ctx->sync_id << ", r=" << r << dendl;
 
   if (sync_ctx->on_complete != nullptr) {
     sync_ctx->on_complete->complete(r);
@@ -590,7 +590,7 @@ void InstanceWatcher<I>::handle_notify_sync_complete(C_SyncRequest *sync_ctx,
 
 template <typename I>
 void InstanceWatcher<I>::print_sync_status(Formatter *f, stringstream *ss) {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   Mutex::Locker locker(m_lock);
   if (m_image_sync_throttler != nullptr) {
@@ -600,7 +600,7 @@ void InstanceWatcher<I>::print_sync_status(Formatter *f, stringstream *ss) {
 
 template <typename I>
 void InstanceWatcher<I>::handle_acquire_leader() {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   Mutex::Locker locker(m_lock);
 
@@ -613,7 +613,7 @@ void InstanceWatcher<I>::handle_acquire_leader() {
 
 template <typename I>
 void InstanceWatcher<I>::handle_release_leader() {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   Mutex::Locker locker(m_lock);
 
@@ -629,7 +629,7 @@ void InstanceWatcher<I>::handle_release_leader() {
 template <typename I>
 void InstanceWatcher<I>::handle_update_leader(
   const std::string &leader_instance_id) {
-  dout(20) << "leader_instance_id=" << leader_instance_id << dendl;
+  dout(10) << "leader_instance_id=" << leader_instance_id << dendl;
 
   Mutex::Locker locker(m_lock);
 
@@ -643,7 +643,7 @@ void InstanceWatcher<I>::handle_update_leader(
 template <typename I>
 void InstanceWatcher<I>::cancel_notify_requests(
     const std::string &instance_id) {
-  dout(20) << "instance_id=" << instance_id << dendl;
+  dout(10) << "instance_id=" << instance_id << dendl;
 
   Mutex::Locker locker(m_lock);
 
@@ -658,7 +658,7 @@ template <typename I>
 void InstanceWatcher<I>::register_instance() {
   assert(m_lock.is_locked());
 
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   librados::ObjectWriteOperation op;
   librbd::cls_client::mirror_instances_add(&op, m_instance_id);
@@ -672,7 +672,7 @@ void InstanceWatcher<I>::register_instance() {
 
 template <typename I>
 void InstanceWatcher<I>::handle_register_instance(int r) {
-  dout(20) << "r=" << r << dendl;
+  dout(10) << "r=" << r << dendl;
 
   Context *on_finish = nullptr;
   {
@@ -693,7 +693,7 @@ void InstanceWatcher<I>::handle_register_instance(int r) {
 
 template <typename I>
 void InstanceWatcher<I>::create_instance_object() {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   assert(m_lock.is_locked());
 
@@ -710,7 +710,7 @@ void InstanceWatcher<I>::create_instance_object() {
 
 template <typename I>
 void InstanceWatcher<I>::handle_create_instance_object(int r) {
-  dout(20) << "r=" << r << dendl;
+  dout(10) << "r=" << r << dendl;
 
   Mutex::Locker locker(m_lock);
 
@@ -728,7 +728,7 @@ void InstanceWatcher<I>::handle_create_instance_object(int r) {
 
 template <typename I>
 void InstanceWatcher<I>::register_watch() {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   assert(m_lock.is_locked());
 
@@ -741,7 +741,7 @@ void InstanceWatcher<I>::register_watch() {
 
 template <typename I>
 void InstanceWatcher<I>::handle_register_watch(int r) {
-  dout(20) << "r=" << r << dendl;
+  dout(10) << "r=" << r << dendl;
 
   Mutex::Locker locker(m_lock);
 
@@ -759,7 +759,7 @@ void InstanceWatcher<I>::handle_register_watch(int r) {
 
 template <typename I>
 void InstanceWatcher<I>::acquire_lock() {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   assert(m_lock.is_locked());
 
@@ -772,7 +772,7 @@ void InstanceWatcher<I>::acquire_lock() {
 
 template <typename I>
 void InstanceWatcher<I>::handle_acquire_lock(int r) {
-  dout(20) << "r=" << r << dendl;
+  dout(10) << "r=" << r << dendl;
 
   Context *on_finish = nullptr;
   {
@@ -795,7 +795,7 @@ void InstanceWatcher<I>::handle_acquire_lock(int r) {
 
 template <typename I>
 void InstanceWatcher<I>::release_lock() {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   assert(m_lock.is_locked());
 
@@ -808,7 +808,7 @@ void InstanceWatcher<I>::release_lock() {
 
 template <typename I>
 void InstanceWatcher<I>::handle_release_lock(int r) {
-  dout(20) << "r=" << r << dendl;
+  dout(10) << "r=" << r << dendl;
 
   Mutex::Locker locker(m_lock);
 
@@ -821,7 +821,7 @@ void InstanceWatcher<I>::handle_release_lock(int r) {
 
 template <typename I>
 void InstanceWatcher<I>::unregister_watch() {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   assert(m_lock.is_locked());
 
@@ -834,7 +834,7 @@ void InstanceWatcher<I>::unregister_watch() {
 
 template <typename I>
 void InstanceWatcher<I>::handle_unregister_watch(int r) {
-  dout(20) << "r=" << r << dendl;
+  dout(10) << "r=" << r << dendl;
 
   if (r < 0) {
     derr << "error unregistering instance watcher for " << m_oid << " object: "
@@ -849,7 +849,7 @@ template <typename I>
 void InstanceWatcher<I>::remove_instance_object() {
   assert(m_lock.is_locked());
 
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   librados::ObjectWriteOperation op;
   op.remove();
@@ -864,7 +864,7 @@ void InstanceWatcher<I>::remove_instance_object() {
 
 template <typename I>
 void InstanceWatcher<I>::handle_remove_instance_object(int r) {
-  dout(20) << "r=" << r << dendl;
+  dout(10) << "r=" << r << dendl;
 
   if (m_removing && r == -ENOENT) {
     r = 0;
@@ -881,7 +881,7 @@ void InstanceWatcher<I>::handle_remove_instance_object(int r) {
 
 template <typename I>
 void InstanceWatcher<I>::unregister_instance() {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   assert(m_lock.is_locked());
 
@@ -897,7 +897,7 @@ void InstanceWatcher<I>::unregister_instance() {
 
 template <typename I>
 void InstanceWatcher<I>::handle_unregister_instance(int r) {
-  dout(20) << "r=" << r << dendl;
+  dout(10) << "r=" << r << dendl;
 
   if (r < 0) {
     derr << "error unregistering instance: " << cpp_strerror(r) << dendl;
@@ -909,7 +909,7 @@ void InstanceWatcher<I>::handle_unregister_instance(int r) {
 
 template <typename I>
 void InstanceWatcher<I>::wait_for_notify_ops() {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   assert(m_lock.is_locked());
 
@@ -926,7 +926,7 @@ void InstanceWatcher<I>::wait_for_notify_ops() {
 
 template <typename I>
 void InstanceWatcher<I>::handle_wait_for_notify_ops(int r) {
-  dout(20) << "r=" << r << dendl;
+  dout(10) << "r=" << r << dendl;
 
   assert(r == 0);
 
@@ -948,7 +948,7 @@ void InstanceWatcher<I>::handle_wait_for_notify_ops(int r) {
 
 template <typename I>
 void InstanceWatcher<I>::get_instance_locker() {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   assert(m_lock.is_locked());
 
@@ -961,7 +961,7 @@ void InstanceWatcher<I>::get_instance_locker() {
 
 template <typename I>
 void InstanceWatcher<I>::handle_get_instance_locker(int r) {
-  dout(20) << "r=" << r << dendl;
+  dout(10) << "r=" << r << dendl;
 
   Mutex::Locker locker(m_lock);
 
@@ -978,7 +978,7 @@ void InstanceWatcher<I>::handle_get_instance_locker(int r) {
 
 template <typename I>
 void InstanceWatcher<I>::break_instance_lock() {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   assert(m_lock.is_locked());
 
@@ -991,7 +991,7 @@ void InstanceWatcher<I>::break_instance_lock() {
 
 template <typename I>
 void InstanceWatcher<I>::handle_break_instance_lock(int r) {
-  dout(20) << "r=" << r << dendl;
+  dout(10) << "r=" << r << dendl;
 
   Mutex::Locker locker(m_lock);
 
@@ -1008,7 +1008,7 @@ void InstanceWatcher<I>::handle_break_instance_lock(int r) {
 
 template <typename I>
 void InstanceWatcher<I>::suspend_notify_request(C_NotifyInstanceRequest *req) {
-  dout(20) << req << dendl;
+  dout(10) << req << dendl;
 
   assert(m_lock.is_locked());
 
@@ -1019,7 +1019,7 @@ void InstanceWatcher<I>::suspend_notify_request(C_NotifyInstanceRequest *req) {
 template <typename I>
 bool InstanceWatcher<I>::unsuspend_notify_request(
   C_NotifyInstanceRequest *req) {
-  dout(20) << req << dendl;
+  dout(10) << req << dendl;
 
   assert(m_lock.is_locked());
 
@@ -1034,7 +1034,7 @@ bool InstanceWatcher<I>::unsuspend_notify_request(
 
 template <typename I>
 void InstanceWatcher<I>::unsuspend_notify_requests() {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   assert(m_lock.is_locked());
 
@@ -1050,7 +1050,7 @@ template <typename I>
 Context *InstanceWatcher<I>::prepare_request(const std::string &instance_id,
                                              uint64_t request_id,
                                              C_NotifyAck *on_notify_ack) {
-  dout(20) << "instance_id=" << instance_id << ", request_id=" << request_id
+  dout(10) << "instance_id=" << instance_id << ", request_id=" << request_id
            << dendl;
 
   Mutex::Locker locker(m_lock);
@@ -1060,7 +1060,7 @@ Context *InstanceWatcher<I>::prepare_request(const std::string &instance_id,
   auto it = m_requests.find(request);
 
   if (it != m_requests.end()) {
-    dout(20) << "duplicate for in-progress request" << dendl;
+    dout(10) << "duplicate for in-progress request" << dendl;
     delete it->on_notify_ack;
     m_requests.erase(it);
   } else {
@@ -1079,7 +1079,7 @@ Context *InstanceWatcher<I>::prepare_request(const std::string &instance_id,
 template <typename I>
 void InstanceWatcher<I>::complete_request(const std::string &instance_id,
                                           uint64_t request_id, int r) {
-  dout(20) << "instance_id=" << instance_id << ", request_id=" << request_id
+  dout(10) << "instance_id=" << instance_id << ", request_id=" << request_id
            << dendl;
 
   C_NotifyAck *on_notify_ack;
@@ -1099,7 +1099,7 @@ void InstanceWatcher<I>::complete_request(const std::string &instance_id,
 template <typename I>
 void InstanceWatcher<I>::handle_notify(uint64_t notify_id, uint64_t handle,
                                        uint64_t notifier_id, bufferlist &bl) {
-  dout(20) << "notify_id=" << notify_id << ", handle=" << handle << ", "
+  dout(10) << "notify_id=" << notify_id << ", handle=" << handle << ", "
            << "notifier_id=" << notifier_id << dendl;
 
   auto ctx = new C_NotifyAck(this, notify_id, handle);
@@ -1121,7 +1121,7 @@ void InstanceWatcher<I>::handle_notify(uint64_t notify_id, uint64_t handle,
 template <typename I>
 void InstanceWatcher<I>::handle_image_acquire(
     const std::string &global_image_id, Context *on_finish) {
-  dout(20) << "global_image_id=" << global_image_id << dendl;
+  dout(10) << "global_image_id=" << global_image_id << dendl;
 
   auto ctx = new FunctionContext(
       [this, global_image_id, on_finish] (int r) {
@@ -1136,7 +1136,7 @@ void InstanceWatcher<I>::handle_image_acquire(
 template <typename I>
 void InstanceWatcher<I>::handle_image_release(
     const std::string &global_image_id, Context *on_finish) {
-  dout(20) << "global_image_id=" << global_image_id << dendl;
+  dout(10) << "global_image_id=" << global_image_id << dendl;
 
   auto ctx = new FunctionContext(
       [this, global_image_id, on_finish] (int r) {
@@ -1152,7 +1152,7 @@ template <typename I>
 void InstanceWatcher<I>::handle_peer_image_removed(
     const std::string &global_image_id, const std::string &peer_mirror_uuid,
     Context *on_finish) {
-  dout(20) << "global_image_id=" << global_image_id << ", "
+  dout(10) << "global_image_id=" << global_image_id << ", "
            << "peer_mirror_uuid=" << peer_mirror_uuid << dendl;
 
   auto ctx = new FunctionContext(
@@ -1170,12 +1170,12 @@ template <typename I>
 void InstanceWatcher<I>::handle_sync_request(const std::string &instance_id,
                                              const std::string &sync_id,
                                              Context *on_finish) {
-  dout(20) << "instance_id=" << instance_id << ", sync_id=" << sync_id << dendl;
+  dout(10) << "instance_id=" << instance_id << ", sync_id=" << sync_id << dendl;
 
   Mutex::Locker locker(m_lock);
 
   if (m_image_sync_throttler == nullptr) {
-    dout(20) << "sync request for non-leader" << dendl;
+    dout(10) << "sync request for non-leader" << dendl;
     m_work_queue->queue(on_finish, -ESTALE);
     return;
   }
@@ -1183,7 +1183,7 @@ void InstanceWatcher<I>::handle_sync_request(const std::string &instance_id,
   Context *on_start = create_async_context_callback(
     m_work_queue, new FunctionContext(
       [this, instance_id, sync_id, on_finish] (int r) {
-        dout(20) << "handle_sync_request: finish: instance_id=" << instance_id
+        dout(10) << "handle_sync_request: finish: instance_id=" << instance_id
                  << ", sync_id=" << sync_id << ", r=" << r << dendl;
         if (r == 0) {
           notify_sync_start(instance_id, sync_id);
@@ -1197,13 +1197,13 @@ template <typename I>
 void InstanceWatcher<I>::handle_sync_start(const std::string &instance_id,
                                            const std::string &sync_id,
                                            Context *on_finish) {
-  dout(20) << "instance_id=" << instance_id << ", sync_id=" << sync_id << dendl;
+  dout(10) << "instance_id=" << instance_id << ", sync_id=" << sync_id << dendl;
 
   Mutex::Locker locker(m_lock);
 
   auto it = m_inflight_sync_reqs.find(sync_id);
   if (it == m_inflight_sync_reqs.end()) {
-    dout(20) << "not found" << dendl;
+    dout(5) << "not found" << dendl;
     m_work_queue->queue(on_finish, 0);
     return;
   }
@@ -1211,7 +1211,7 @@ void InstanceWatcher<I>::handle_sync_start(const std::string &instance_id,
   auto sync_ctx = it->second;
 
   if (sync_ctx->on_complete != nullptr) {
-    dout(20) << "duplicate request" << dendl;
+    dout(5) << "duplicate request" << dendl;
     m_work_queue->queue(sync_ctx->on_complete, -ESTALE);
   }
 
@@ -1222,7 +1222,7 @@ template <typename I>
 void InstanceWatcher<I>::handle_payload(const std::string &instance_id,
                                         const ImageAcquirePayload &payload,
                                         C_NotifyAck *on_notify_ack) {
-  dout(20) << "image_acquire: instance_id=" << instance_id << ", "
+  dout(10) << "image_acquire: instance_id=" << instance_id << ", "
            << "request_id=" << payload.request_id << dendl;
 
   auto on_finish = prepare_request(instance_id, payload.request_id,
@@ -1236,7 +1236,7 @@ template <typename I>
 void InstanceWatcher<I>::handle_payload(const std::string &instance_id,
                                         const ImageReleasePayload &payload,
                                         C_NotifyAck *on_notify_ack) {
-  dout(20) << "image_release: instance_id=" << instance_id << ", "
+  dout(10) << "image_release: instance_id=" << instance_id << ", "
            << "request_id=" << payload.request_id << dendl;
 
   auto on_finish = prepare_request(instance_id, payload.request_id,
@@ -1250,7 +1250,7 @@ template <typename I>
 void InstanceWatcher<I>::handle_payload(const std::string &instance_id,
                                         const PeerImageRemovedPayload &payload,
                                         C_NotifyAck *on_notify_ack) {
-  dout(20) << "remove_peer_image: instance_id=" << instance_id << ", "
+  dout(10) << "remove_peer_image: instance_id=" << instance_id << ", "
            << "request_id=" << payload.request_id << dendl;
 
   auto on_finish = prepare_request(instance_id, payload.request_id,
@@ -1265,7 +1265,7 @@ template <typename I>
 void InstanceWatcher<I>::handle_payload(const std::string &instance_id,
                                         const SyncRequestPayload &payload,
                                         C_NotifyAck *on_notify_ack) {
-  dout(20) << "sync_request: instance_id=" << instance_id << ", "
+  dout(10) << "sync_request: instance_id=" << instance_id << ", "
            << "request_id=" << payload.request_id << dendl;
 
   auto on_finish = prepare_request(instance_id, payload.request_id,
@@ -1281,7 +1281,7 @@ template <typename I>
 void InstanceWatcher<I>::handle_payload(const std::string &instance_id,
                                         const SyncStartPayload &payload,
                                         C_NotifyAck *on_notify_ack) {
-  dout(20) << "sync_start: instance_id=" << instance_id << ", "
+  dout(10) << "sync_start: instance_id=" << instance_id << ", "
            << "request_id=" << payload.request_id << dendl;
 
   auto on_finish = prepare_request(instance_id, payload.request_id,
@@ -1297,7 +1297,7 @@ template <typename I>
 void InstanceWatcher<I>::handle_payload(const std::string &instance_id,
                                         const UnknownPayload &payload,
                                         C_NotifyAck *on_notify_ack) {
-  dout(20) << "unknown: instance_id=" << instance_id << dendl;
+  dout(5) << "unknown: instance_id=" << instance_id << dendl;
 
   on_notify_ack->complete(0);
 }

diff --git a/src/tools/rbd_mirror/Instances.cc b/src/tools/rbd_mirror/Instances.cc
index 4513869d3f048fa92480f36f1b75853b29b39ad1..7f4033570b66f649bcac5dd0fbb87263b08a6885 100644 (file)
--- a/src/tools/rbd_mirror/Instances.cc
+++ b/src/tools/rbd_mirror/Instances.cc
@@ -38,7 +38,7 @@ Instances<I>::~Instances() {
 
 template <typename I>
 void Instances<I>::init(Context *on_finish) {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   Mutex::Locker locker(m_lock);
   assert(m_on_finish == nullptr);
@@ -48,7 +48,7 @@ void Instances<I>::init(Context *on_finish) {
 
 template <typename I>
 void Instances<I>::shut_down(Context *on_finish) {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   Mutex::Locker locker(m_lock);
   assert(m_on_finish == nullptr);
@@ -88,11 +88,11 @@ void Instances<I>::unblock_listener() {
 
 template <typename I>
 void Instances<I>::acked(const InstanceIds& instance_ids) {
-  dout(20) << "instance_ids=" << instance_ids << dendl;
+  dout(10) << "instance_ids=" << instance_ids << dendl;
 
   Mutex::Locker locker(m_lock);
   if (m_on_finish != nullptr) {
-    dout(20) << "received on shut down, ignoring" << dendl;
+    dout(5) << "received on shut down, ignoring" << dendl;
     return;
   }
 
@@ -107,7 +107,7 @@ void Instances<I>::handle_acked(const InstanceIds& instance_ids) {
   Mutex::Locker timer_locker(m_threads->timer_lock);
   Mutex::Locker locker(m_lock);
   if (m_on_finish != nullptr) {
-    dout(20) << "handled on shut down, ignoring" << dendl;
+    dout(5) << "handled on shut down, ignoring" << dendl;
     return;
   }
 
@@ -182,7 +182,7 @@ void Instances<I>::list(std::vector<std::string> *instance_ids) {
 
 template <typename I>
 void Instances<I>::get_instances() {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   assert(m_lock.is_locked());
 
@@ -194,7 +194,7 @@ void Instances<I>::get_instances() {
 
 template <typename I>
 void Instances<I>::handle_get_instances(int r) {
-  dout(20) << "r=" << r << dendl;
+  dout(10) << "r=" << r << dendl;
 
   Context *on_finish = nullptr;
   {
@@ -212,7 +212,7 @@ void Instances<I>::handle_get_instances(int r) {
 
 template <typename I>
 void Instances<I>::wait_for_ops() {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   assert(m_lock.is_locked());
 
@@ -225,7 +225,7 @@ void Instances<I>::wait_for_ops() {
 
 template <typename I>
 void Instances<I>::handle_wait_for_ops(int r) {
-  dout(20) << "r=" << r << dendl;
+  dout(10) << "r=" << r << dendl;
 
   assert(r == 0);
 
@@ -252,7 +252,7 @@ void Instances<I>::remove_instances(const utime_t& time) {
   }
   assert(!instance_ids.empty());
 
-  dout(20) << "instance_ids=" << instance_ids << dendl;
+  dout(10) << "instance_ids=" << instance_ids << dendl;
   Context* ctx = new FunctionContext([this, instance_ids](int r) {
       handle_remove_instances(r, instance_ids);
     });
@@ -274,7 +274,7 @@ void Instances<I>::handle_remove_instances(
   Mutex::Locker timer_locker(m_threads->timer_lock);
   Mutex::Locker locker(m_lock);
 
-  dout(20) << "r=" << r << ", instance_ids=" << instance_ids << dendl;
+  dout(10) << "r=" << r << ", instance_ids=" << instance_ids << dendl;
   assert(r == 0);
 
   // fire removed notification now that instaces have been blacklisted
@@ -295,7 +295,7 @@ void Instances<I>::cancel_remove_task() {
     return;
   }
 
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   bool canceled = m_threads->timer->cancel_event(m_timer_task);
   assert(canceled);
@@ -306,7 +306,7 @@ template <typename I>
 void Instances<I>::schedule_remove_task(const utime_t& time) {
   cancel_remove_task();
   if (m_on_finish != nullptr) {
-    dout(20) << "received on shut down, ignoring" << dendl;
+    dout(10) << "received on shut down, ignoring" << dendl;
     return;
   }
 
@@ -330,7 +330,7 @@ void Instances<I>::schedule_remove_task(const utime_t& time) {
     return;
   }
 
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   // schedule a time to fire when the oldest instance should be removed
   m_timer_task = new FunctionContext(

diff --git a/src/tools/rbd_mirror/LeaderWatcher.cc b/src/tools/rbd_mirror/LeaderWatcher.cc
index c3acb21f6abdd276f0e6735d114d35718b446414..f9edf021b7742cde5a26695a1c195b4a9ad87241 100644 (file)
--- a/src/tools/rbd_mirror/LeaderWatcher.cc
+++ b/src/tools/rbd_mirror/LeaderWatcher.cc
@@ -60,7 +60,7 @@ int LeaderWatcher<I>::init() {
 
 template <typename I>
 void LeaderWatcher<I>::init(Context *on_finish) {
-  dout(20) << "notifier_id=" << m_notifier_id << dendl;
+  dout(10) << "notifier_id=" << m_notifier_id << dendl;
 
   Mutex::Locker locker(m_lock);
 
@@ -72,7 +72,7 @@ void LeaderWatcher<I>::init(Context *on_finish) {
 
 template <typename I>
 void LeaderWatcher<I>::create_leader_object() {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   assert(m_lock.is_locked());
 
@@ -88,7 +88,7 @@ void LeaderWatcher<I>::create_leader_object() {
 
 template <typename I>
 void LeaderWatcher<I>::handle_create_leader_object(int r) {
-  dout(20) << "r=" << r << dendl;
+  dout(10) << "r=" << r << dendl;
 
   Context *on_finish = nullptr;
   {
@@ -109,7 +109,7 @@ void LeaderWatcher<I>::handle_create_leader_object(int r) {
 
 template <typename I>
 void LeaderWatcher<I>::register_watch() {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   assert(m_lock.is_locked());
 
@@ -122,7 +122,7 @@ void LeaderWatcher<I>::register_watch() {
 
 template <typename I>
 void LeaderWatcher<I>::handle_register_watch(int r) {
-  dout(20) << "r=" << r << dendl;
+  dout(10) << "r=" << r << dendl;
 
   Context *on_finish = nullptr;
   if (r < 0) {
@@ -150,7 +150,7 @@ void LeaderWatcher<I>::shut_down() {
 
 template <typename I>
 void LeaderWatcher<I>::shut_down(Context *on_finish) {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   Mutex::Locker timer_locker(m_threads->timer_lock);
   Mutex::Locker locker(m_lock);
@@ -163,7 +163,7 @@ void LeaderWatcher<I>::shut_down(Context *on_finish) {
 
 template <typename I>
 void LeaderWatcher<I>::shut_down_leader_lock() {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   assert(m_lock.is_locked());
 
@@ -176,7 +176,7 @@ void LeaderWatcher<I>::shut_down_leader_lock() {
 
 template <typename I>
 void LeaderWatcher<I>::handle_shut_down_leader_lock(int r) {
-  dout(20) << "r=" << r << dendl;
+  dout(10) << "r=" << r << dendl;
 
   Mutex::Locker locker(m_lock);
 
@@ -189,7 +189,7 @@ void LeaderWatcher<I>::handle_shut_down_leader_lock(int r) {
 
 template <typename I>
 void LeaderWatcher<I>::unregister_watch() {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   assert(m_lock.is_locked());
 
@@ -202,7 +202,7 @@ void LeaderWatcher<I>::unregister_watch() {
 
 template <typename I>
 void LeaderWatcher<I>::handle_unregister_watch(int r) {
-  dout(20) << "r=" << r << dendl;
+  dout(10) << "r=" << r << dendl;
 
   if (r < 0) {
     derr << "error unregistering leader watcher for " << m_oid << " object: "
@@ -213,7 +213,7 @@ void LeaderWatcher<I>::handle_unregister_watch(int r) {
 
 template <typename I>
 void LeaderWatcher<I>::wait_for_tasks() {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   Mutex::Locker timer_locker(m_threads->timer_lock);
   Mutex::Locker locker(m_lock);
@@ -223,7 +223,7 @@ void LeaderWatcher<I>::wait_for_tasks() {
 
 template <typename I>
 void LeaderWatcher<I>::handle_wait_for_tasks() {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   assert(m_threads->timer_lock.is_locked());
   assert(m_lock.is_locked());
@@ -257,7 +257,7 @@ bool LeaderWatcher<I>::is_leader(Mutex &lock) const {
   assert(m_lock.is_locked());
 
   bool leader = m_leader_lock->is_leader();
-  dout(20) << leader << dendl;
+  dout(10) << leader << dendl;
   return leader;
 }
 
@@ -273,13 +273,13 @@ bool LeaderWatcher<I>::is_releasing_leader(Mutex &lock) const {
   assert(m_lock.is_locked());
 
   bool releasing = m_leader_lock->is_releasing_leader();
-  dout(20) << releasing << dendl;
+  dout(10) << releasing << dendl;
   return releasing;
 }
 
 template <typename I>
 bool LeaderWatcher<I>::get_leader_instance_id(std::string *instance_id) const {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   Mutex::Locker locker(m_lock);
 
@@ -298,7 +298,7 @@ bool LeaderWatcher<I>::get_leader_instance_id(std::string *instance_id) const {
 
 template <typename I>
 void LeaderWatcher<I>::release_leader() {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   Mutex::Locker locker(m_lock);
   if (!is_leader(m_lock)) {
@@ -310,7 +310,7 @@ void LeaderWatcher<I>::release_leader() {
 
 template <typename I>
 void LeaderWatcher<I>::list_instances(std::vector<std::string> *instance_ids) {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   Mutex::Locker locker(m_lock);
 
@@ -329,7 +329,7 @@ void LeaderWatcher<I>::cancel_timer_task() {
     return;
   }
 
-  dout(20) << m_timer_task << dendl;
+  dout(10) << m_timer_task << dendl;
   bool canceled = m_threads->timer->cancel_event(m_timer_task);
   assert(canceled);
   m_timer_task = nullptr;
@@ -373,7 +373,7 @@ void LeaderWatcher<I>::schedule_timer_task(const std::string &name,
   int after = delay_factor * m_cct->_conf->get_val<int64_t>(
     "rbd_mirror_leader_heartbeat_interval");
 
-  dout(20) << "scheduling " << name << " after " << after << " sec (task "
+  dout(10) << "scheduling " << name << " after " << after << " sec (task "
            << m_timer_task << ")" << dendl;
   m_threads->timer->add_event_after(after, m_timer_task);
 }
@@ -381,7 +381,7 @@ void LeaderWatcher<I>::schedule_timer_task(const std::string &name,
 template <typename I>
 void LeaderWatcher<I>::execute_timer_task(bool leader,
                                           TimerCallback timer_callback) {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   assert(m_threads->timer_lock.is_locked());
   assert(m_lock.is_locked());
@@ -398,11 +398,11 @@ void LeaderWatcher<I>::execute_timer_task(bool leader,
 template <typename I>
 void LeaderWatcher<I>::handle_post_acquire_leader_lock(int r,
                                                        Context *on_finish) {
-  dout(20) << "r=" << r << dendl;
+  dout(10) << "r=" << r << dendl;
 
   if (r < 0) {
     if (r == -EAGAIN) {
-      dout(20) << "already locked" << dendl;
+      dout(10) << "already locked" << dendl;
     } else {
       derr << "error acquiring leader lock: " << cpp_strerror(r) << dendl;
     }
@@ -420,7 +420,7 @@ void LeaderWatcher<I>::handle_post_acquire_leader_lock(int r,
 
 template <typename I>
 void LeaderWatcher<I>::handle_pre_release_leader_lock(Context *on_finish) {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   Mutex::Locker locker(m_lock);
   assert(m_on_finish == nullptr);
@@ -433,7 +433,7 @@ void LeaderWatcher<I>::handle_pre_release_leader_lock(Context *on_finish) {
 template <typename I>
 void LeaderWatcher<I>::handle_post_release_leader_lock(int r,
                                                        Context *on_finish) {
-  dout(20) << "r=" << r << dendl;
+  dout(10) << "r=" << r << dendl;
 
   if (r < 0) {
     on_finish->complete(r);
@@ -449,7 +449,7 @@ void LeaderWatcher<I>::handle_post_release_leader_lock(int r,
 
 template <typename I>
 void LeaderWatcher<I>::break_leader_lock() {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   assert(m_threads->timer_lock.is_locked());
   assert(m_lock.is_locked());
@@ -469,14 +469,14 @@ void LeaderWatcher<I>::break_leader_lock() {
 
 template <typename I>
 void LeaderWatcher<I>::handle_break_leader_lock(int r) {
-  dout(20) << "r=" << r << dendl;
+  dout(10) << "r=" << r << dendl;
 
   Mutex::Locker timer_locker(m_threads->timer_lock);
   Mutex::Locker locker(m_lock);
   assert(!m_timer_op_tracker.empty());
 
   if (m_leader_lock->is_shutdown()) {
-    dout(20) << "canceling due to shutdown" << dendl;
+    dout(10) << "canceling due to shutdown" << dendl;
     m_timer_op_tracker.finish_op();
     return;
   }
@@ -496,7 +496,7 @@ void LeaderWatcher<I>::handle_break_leader_lock(int r) {
 template <typename I>
 void LeaderWatcher<I>::schedule_get_locker(bool reset_leader,
                                            uint32_t delay_factor) {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   assert(m_threads->timer_lock.is_locked());
   assert(m_lock.is_locked());
@@ -512,7 +512,7 @@ void LeaderWatcher<I>::schedule_get_locker(bool reset_leader,
 
 template <typename I>
 void LeaderWatcher<I>::get_locker() {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   assert(m_threads->timer_lock.is_locked());
   assert(m_lock.is_locked());
@@ -527,14 +527,14 @@ void LeaderWatcher<I>::get_locker() {
 template <typename I>
 void LeaderWatcher<I>::handle_get_locker(int r,
                                          librbd::managed_lock::Locker& locker) {
-  dout(20) << "r=" << r << dendl;
+  dout(10) << "r=" << r << dendl;
 
   Mutex::Locker timer_locker(m_threads->timer_lock);
   Mutex::Locker mutex_locker(m_lock);
   assert(!m_timer_op_tracker.empty());
 
   if (m_leader_lock->is_shutdown()) {
-    dout(20) << "canceling due to shutdown" << dendl;
+    dout(10) << "canceling due to shutdown" << dendl;
     m_timer_op_tracker.finish_op();
     return;
   }
@@ -598,7 +598,7 @@ void LeaderWatcher<I>::handle_get_locker(int r,
 
 template <typename I>
 void LeaderWatcher<I>::schedule_acquire_leader_lock(uint32_t delay_factor) {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   assert(m_threads->timer_lock.is_locked());
   assert(m_lock.is_locked());
@@ -616,7 +616,7 @@ void LeaderWatcher<I>::acquire_leader_lock() {
   assert(!m_timer_op_tracker.empty());
 
   ++m_acquire_attempts;
-  dout(20) << "acquire_attempts=" << m_acquire_attempts << dendl;
+  dout(10) << "acquire_attempts=" << m_acquire_attempts << dendl;
 
   Context *ctx = create_async_context_callback(
     m_work_queue, create_context_callback<
@@ -626,21 +626,21 @@ void LeaderWatcher<I>::acquire_leader_lock() {
 
 template <typename I>
 void LeaderWatcher<I>::handle_acquire_leader_lock(int r) {
-  dout(20) << "r=" << r << dendl;
+  dout(10) << "r=" << r << dendl;
 
   Mutex::Locker timer_locker(m_threads->timer_lock);
   Mutex::Locker locker(m_lock);
   assert(!m_timer_op_tracker.empty());
 
   if (m_leader_lock->is_shutdown()) {
-    dout(20) << "canceling due to shutdown" << dendl;
+    dout(10) << "canceling due to shutdown" << dendl;
     m_timer_op_tracker.finish_op();
     return;
   }
 
   if (r < 0) {
     if (r == -EAGAIN) {
-      dout(20) << "already locked" << dendl;
+      dout(10) << "already locked" << dendl;
     } else {
       derr << "error acquiring lock: " << cpp_strerror(r) << dendl;
     }
@@ -664,7 +664,7 @@ void LeaderWatcher<I>::handle_acquire_leader_lock(int r) {
 
 template <typename I>
 void LeaderWatcher<I>::release_leader_lock() {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   assert(m_lock.is_locked());
 
@@ -677,7 +677,7 @@ void LeaderWatcher<I>::release_leader_lock() {
 
 template <typename I>
 void LeaderWatcher<I>::handle_release_leader_lock(int r) {
-  dout(20) << "r=" << r << dendl;
+  dout(10) << "r=" << r << dendl;
 
   Mutex::Locker timer_locker(m_threads->timer_lock);
   Mutex::Locker locker(m_lock);
@@ -692,7 +692,7 @@ void LeaderWatcher<I>::handle_release_leader_lock(int r) {
 
 template <typename I>
 void LeaderWatcher<I>::init_status_watcher() {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   assert(m_lock.is_locked());
   assert(m_status_watcher == nullptr);
@@ -707,7 +707,7 @@ void LeaderWatcher<I>::init_status_watcher() {
 
 template <typename I>
 void LeaderWatcher<I>::handle_init_status_watcher(int r) {
-  dout(20) << "r=" << r << dendl;
+  dout(10) << "r=" << r << dendl;
 
   Context *on_finish = nullptr;
   {
@@ -730,7 +730,7 @@ void LeaderWatcher<I>::handle_init_status_watcher(int r) {
 
 template <typename I>
 void LeaderWatcher<I>::shut_down_status_watcher() {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   assert(m_lock.is_locked());
   assert(m_status_watcher != nullptr);
@@ -744,7 +744,7 @@ void LeaderWatcher<I>::shut_down_status_watcher() {
 
 template <typename I>
 void LeaderWatcher<I>::handle_shut_down_status_watcher(int r) {
-  dout(20) << "r=" << r << dendl;
+  dout(10) << "r=" << r << dendl;
 
   Mutex::Locker locker(m_lock);
   m_status_watcher->destroy();
@@ -760,7 +760,7 @@ void LeaderWatcher<I>::handle_shut_down_status_watcher(int r) {
 
 template <typename I>
 void LeaderWatcher<I>::init_instances() {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   assert(m_lock.is_locked());
   assert(m_instances == nullptr);
@@ -775,7 +775,7 @@ void LeaderWatcher<I>::init_instances() {
 
 template <typename I>
 void LeaderWatcher<I>::handle_init_instances(int r) {
-  dout(20) << "r=" << r << dendl;
+  dout(10) << "r=" << r << dendl;
 
   Context *on_finish = nullptr;
   if (r < 0) {
@@ -797,7 +797,7 @@ void LeaderWatcher<I>::handle_init_instances(int r) {
 
 template <typename I>
 void LeaderWatcher<I>::shut_down_instances() {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   assert(m_lock.is_locked());
   assert(m_instances != nullptr);
@@ -811,7 +811,7 @@ void LeaderWatcher<I>::shut_down_instances() {
 
 template <typename I>
 void LeaderWatcher<I>::handle_shut_down_instances(int r) {
-  dout(20) << "r=" << r << dendl;
+  dout(10) << "r=" << r << dendl;
   assert(r == 0);
 
   Context *on_finish = nullptr;
@@ -829,7 +829,7 @@ void LeaderWatcher<I>::handle_shut_down_instances(int r) {
 
 template <typename I>
 void LeaderWatcher<I>::notify_listener() {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   assert(m_lock.is_locked());
 
@@ -853,7 +853,7 @@ void LeaderWatcher<I>::notify_listener() {
 
 template <typename I>
 void LeaderWatcher<I>::handle_notify_listener(int r) {
-  dout(20) << "r=" << r << dendl;
+  dout(10) << "r=" << r << dendl;
 
   Mutex::Locker locker(m_lock);
 
@@ -871,7 +871,7 @@ void LeaderWatcher<I>::handle_notify_listener(int r) {
 
 template <typename I>
 void LeaderWatcher<I>::notify_lock_acquired() {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   assert(m_lock.is_locked());
 
@@ -886,7 +886,7 @@ void LeaderWatcher<I>::notify_lock_acquired() {
 
 template <typename I>
 void LeaderWatcher<I>::handle_notify_lock_acquired(int r) {
-  dout(20) << "r=" << r << dendl;
+  dout(10) << "r=" << r << dendl;
 
   Context *on_finish = nullptr;
   {
@@ -908,7 +908,7 @@ void LeaderWatcher<I>::handle_notify_lock_acquired(int r) {
 
 template <typename I>
 void LeaderWatcher<I>::notify_lock_released() {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   assert(m_lock.is_locked());
 
@@ -923,7 +923,7 @@ void LeaderWatcher<I>::notify_lock_released() {
 
 template <typename I>
 void LeaderWatcher<I>::handle_notify_lock_released(int r) {
-  dout(20) << "r=" << r << dendl;
+  dout(10) << "r=" << r << dendl;
 
   Context *on_finish = nullptr;
   {
@@ -941,7 +941,7 @@ void LeaderWatcher<I>::handle_notify_lock_released(int r) {
 
 template <typename I>
 void LeaderWatcher<I>::notify_heartbeat() {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   assert(m_threads->timer_lock.is_locked());
   assert(m_lock.is_locked());
@@ -965,7 +965,7 @@ void LeaderWatcher<I>::notify_heartbeat() {
 
 template <typename I>
 void LeaderWatcher<I>::handle_notify_heartbeat(int r) {
-  dout(20) << "r=" << r << dendl;
+  dout(10) << "r=" << r << dendl;
 
   Mutex::Locker timer_locker(m_threads->timer_lock);
   Mutex::Locker locker(m_lock);
@@ -973,7 +973,7 @@ void LeaderWatcher<I>::handle_notify_heartbeat(int r) {
 
   m_timer_op_tracker.finish_op();
   if (m_leader_lock->is_shutdown()) {
-    dout(20) << "canceling due to shutdown" << dendl;
+    dout(10) << "canceling due to shutdown" << dendl;
     return;
   } else if (!is_leader(m_lock)) {
     return;
@@ -986,7 +986,7 @@ void LeaderWatcher<I>::handle_notify_heartbeat(int r) {
     return;
   }
 
-  dout(20) << m_heartbeat_response.acks.size() << " acks received, "
+  dout(10) << m_heartbeat_response.acks.size() << " acks received, "
            << m_heartbeat_response.timeouts.size() << " timed out" << dendl;
 
   std::vector<std::string> instance_ids;
@@ -1008,7 +1008,7 @@ void LeaderWatcher<I>::handle_notify_heartbeat(int r) {
 
 template <typename I>
 void LeaderWatcher<I>::handle_heartbeat(Context *on_notify_ack) {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   {
     Mutex::Locker timer_locker(m_threads->timer_lock);
@@ -1027,7 +1027,7 @@ void LeaderWatcher<I>::handle_heartbeat(Context *on_notify_ack) {
 
 template <typename I>
 void LeaderWatcher<I>::handle_lock_acquired(Context *on_notify_ack) {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   {
     Mutex::Locker timer_locker(m_threads->timer_lock);
@@ -1045,7 +1045,7 @@ void LeaderWatcher<I>::handle_lock_acquired(Context *on_notify_ack) {
 
 template <typename I>
 void LeaderWatcher<I>::handle_lock_released(Context *on_notify_ack) {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   {
     Mutex::Locker timer_locker(m_threads->timer_lock);
@@ -1064,13 +1064,13 @@ void LeaderWatcher<I>::handle_lock_released(Context *on_notify_ack) {
 template <typename I>
 void LeaderWatcher<I>::handle_notify(uint64_t notify_id, uint64_t handle,
                                      uint64_t notifier_id, bufferlist &bl) {
-  dout(20) << "notify_id=" << notify_id << ", handle=" << handle << ", "
+  dout(10) << "notify_id=" << notify_id << ", handle=" << handle << ", "
            << "notifier_id=" << notifier_id << dendl;
 
   Context *ctx = new C_NotifyAck(this, notify_id, handle);
 
   if (notifier_id == m_notifier_id) {
-    dout(20) << "our own notification, ignoring" << dendl;
+    dout(10) << "our own notification, ignoring" << dendl;
     ctx->complete(0);
     return;
   }
@@ -1091,7 +1091,7 @@ void LeaderWatcher<I>::handle_notify(uint64_t notify_id, uint64_t handle,
 template <typename I>
 void LeaderWatcher<I>::handle_payload(const HeartbeatPayload &payload,
                                       Context *on_notify_ack) {
-  dout(20) << "heartbeat" << dendl;
+  dout(10) << "heartbeat" << dendl;
 
   handle_heartbeat(on_notify_ack);
 }
@@ -1099,7 +1099,7 @@ void LeaderWatcher<I>::handle_payload(const HeartbeatPayload &payload,
 template <typename I>
 void LeaderWatcher<I>::handle_payload(const LockAcquiredPayload &payload,
                                       Context *on_notify_ack) {
-  dout(20) << "lock_acquired" << dendl;
+  dout(10) << "lock_acquired" << dendl;
 
   handle_lock_acquired(on_notify_ack);
 }
@@ -1107,7 +1107,7 @@ void LeaderWatcher<I>::handle_payload(const LockAcquiredPayload &payload,
 template <typename I>
 void LeaderWatcher<I>::handle_payload(const LockReleasedPayload &payload,
                                       Context *on_notify_ack) {
-  dout(20) << "lock_released" << dendl;
+  dout(10) << "lock_released" << dendl;
 
   handle_lock_released(on_notify_ack);
 }
@@ -1115,7 +1115,7 @@ void LeaderWatcher<I>::handle_payload(const LockReleasedPayload &payload,
 template <typename I>
 void LeaderWatcher<I>::handle_payload(const UnknownPayload &payload,
                                       Context *on_notify_ack) {
-  dout(20) << "unknown" << dendl;
+  dout(10) << "unknown" << dendl;
 
   on_notify_ack->complete(0);
 }

diff --git a/src/tools/rbd_mirror/PoolReplayer.cc b/src/tools/rbd_mirror/PoolReplayer.cc
index fa592420d41deae14c6b2b7e9d63daf0e52d7455..90d04868a4a5ac08994e489beffc0c804d99cdab 100644 (file)
--- a/src/tools/rbd_mirror/PoolReplayer.cc
+++ b/src/tools/rbd_mirror/PoolReplayer.cc
@@ -276,7 +276,7 @@ void PoolReplayer<I>::init()
   m_stopping = false;
   m_blacklisted = false;
 
-  dout(20) << "replaying for " << m_peer << dendl;
+  dout(10) << "replaying for " << m_peer << dendl;
   int r = init_rados(g_ceph_context->_conf->cluster,
                      g_ceph_context->_conf->name.to_str(),
                      "local cluster", &m_local_rados, false);
@@ -327,7 +327,7 @@ void PoolReplayer<I>::init()
     return;
   }
 
-  dout(20) << "connected to " << m_peer << dendl;
+  dout(10) << "connected to " << m_peer << dendl;
 
   m_instance_replayer.reset(InstanceReplayer<>::create(
     m_threads, m_service_daemon, m_local_rados, local_mirror_uuid,
@@ -701,7 +701,7 @@ void PoolReplayer<I>::handle_update(const std::string &mirror_uuid,
 
 template <typename I>
 void PoolReplayer<I>::handle_post_acquire_leader(Context *on_finish) {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   m_service_daemon->add_or_update_attribute(m_local_pool_id,
                                             SERVICE_DAEMON_LEADER_KEY, true);
@@ -711,7 +711,7 @@ void PoolReplayer<I>::handle_post_acquire_leader(Context *on_finish) {
 
 template <typename I>
 void PoolReplayer<I>::handle_pre_release_leader(Context *on_finish) {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   m_service_daemon->remove_attribute(m_local_pool_id,
                                      SERVICE_DAEMON_LEADER_KEY);
@@ -752,7 +752,7 @@ void PoolReplayer<I>::handle_init_image_map(int r, Context *on_finish) {
 
 template <typename I>
 void PoolReplayer<I>::init_local_pool_watcher(Context *on_finish) {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   Mutex::Locker locker(m_lock);
   assert(!m_local_pool_watcher);
@@ -771,7 +771,7 @@ void PoolReplayer<I>::init_local_pool_watcher(Context *on_finish) {
 template <typename I>
 void PoolReplayer<I>::handle_init_local_pool_watcher(
     int r, Context *on_finish) {
-  dout(20) << "r=" << r << dendl;
+  dout(10) << "r=" << r << dendl;
   if (r < 0) {
     derr << "failed to retrieve local images: " << cpp_strerror(r) << dendl;
     on_finish = new FunctionContext([this, on_finish, r](int) {
@@ -786,7 +786,7 @@ void PoolReplayer<I>::handle_init_local_pool_watcher(
 
 template <typename I>
 void PoolReplayer<I>::init_remote_pool_watcher(Context *on_finish) {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   Mutex::Locker locker(m_lock);
   assert(!m_remote_pool_watcher);
@@ -803,7 +803,7 @@ void PoolReplayer<I>::init_remote_pool_watcher(Context *on_finish) {
 template <typename I>
 void PoolReplayer<I>::handle_init_remote_pool_watcher(
     int r, Context *on_finish) {
-  dout(20) << "r=" << r << dendl;
+  dout(10) << "r=" << r << dendl;
   if (r < 0) {
     derr << "failed to retrieve remote images: " << cpp_strerror(r) << dendl;
     on_finish = new FunctionContext([this, on_finish, r](int) {
@@ -818,7 +818,7 @@ void PoolReplayer<I>::handle_init_remote_pool_watcher(
 
 template <typename I>
 void PoolReplayer<I>::init_image_deleter(Context *on_finish) {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   Mutex::Locker locker(m_lock);
   assert(!m_image_deleter);
@@ -834,7 +834,7 @@ void PoolReplayer<I>::init_image_deleter(Context *on_finish) {
 
 template <typename I>
 void PoolReplayer<I>::handle_init_image_deleter(int r, Context *on_finish) {
-  dout(20) << "r=" << r << dendl;
+  dout(10) << "r=" << r << dendl;
   if (r < 0) {
     derr << "failed to init image deleter: " << cpp_strerror(r) << dendl;
     on_finish = new FunctionContext([this, on_finish, r](int) {
@@ -852,7 +852,7 @@ void PoolReplayer<I>::handle_init_image_deleter(int r, Context *on_finish) {
 
 template <typename I>
 void PoolReplayer<I>::shut_down_image_deleter(Context* on_finish) {
-  dout(20) << dendl;
+  dout(10) << dendl;
   {
     Mutex::Locker locker(m_lock);
     if (m_image_deleter) {
@@ -871,7 +871,7 @@ void PoolReplayer<I>::shut_down_image_deleter(Context* on_finish) {
 template <typename I>
 void PoolReplayer<I>::handle_shut_down_image_deleter(
     int r, Context* on_finish) {
-  dout(20) << "r=" << r << dendl;
+  dout(10) << "r=" << r << dendl;
 
   {
     Mutex::Locker locker(m_lock);
@@ -884,7 +884,7 @@ void PoolReplayer<I>::handle_shut_down_image_deleter(
 
 template <typename I>
 void PoolReplayer<I>::shut_down_pool_watchers(Context *on_finish) {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   {
     Mutex::Locker locker(m_lock);
@@ -910,7 +910,7 @@ void PoolReplayer<I>::shut_down_pool_watchers(Context *on_finish) {
 template <typename I>
 void PoolReplayer<I>::handle_shut_down_pool_watchers(
     int r, Context *on_finish) {
-  dout(20) << "r=" << r << dendl;
+  dout(10) << "r=" << r << dendl;
 
   {
     Mutex::Locker locker(m_lock);
@@ -926,7 +926,7 @@ void PoolReplayer<I>::handle_shut_down_pool_watchers(
 
 template <typename I>
 void PoolReplayer<I>::wait_for_update_ops(Context *on_finish) {
-  dout(20) << dendl;
+  dout(10) << dendl;
 
   Mutex::Locker locker(m_lock);
 
@@ -940,7 +940,7 @@ void PoolReplayer<I>::wait_for_update_ops(Context *on_finish) {
 
 template <typename I>
 void PoolReplayer<I>::handle_wait_for_update_ops(int r, Context *on_finish) {
-  dout(20) << "r=" << r << dendl;
+  dout(10) << "r=" << r << dendl;
   assert(r == 0);
 
   shut_down_image_map(on_finish);
@@ -982,7 +982,7 @@ void PoolReplayer<I>::handle_shut_down_image_map(int r, Context *on_finish) {
 template <typename I>
 void PoolReplayer<I>::handle_update_leader(
     const std::string &leader_instance_id) {
-  dout(20) << "leader_instance_id=" << leader_instance_id << dendl;
+  dout(10) << "leader_instance_id=" << leader_instance_id << dendl;
 
   m_instance_watcher->handle_update_leader(leader_instance_id);
 }

diff --git a/src/tools/rbd_mirror/image_replayer/BootstrapRequest.cc b/src/tools/rbd_mirror/image_replayer/BootstrapRequest.cc
index a91f7fcffa49f4b53799534369c7d34ae936255e..e13652280fc28cf08571c6c5e3dce0459d1dbade 100644 (file)
--- a/src/tools/rbd_mirror/image_replayer/BootstrapRequest.cc
+++ b/src/tools/rbd_mirror/image_replayer/BootstrapRequest.cc
@@ -531,7 +531,7 @@ void BootstrapRequest<I>::handle_get_remote_tags(int r) {
 
     local_tag_tid = local_image_ctx->journal->get_tag_tid();
     local_tag_data = local_image_ctx->journal->get_tag_data();
-    dout(20) << ": local tag " << local_tag_tid << ": "
+    dout(10) << ": local tag " << local_tag_tid << ": "
              << local_tag_data << dendl;
   }
 
@@ -546,7 +546,7 @@ void BootstrapRequest<I>::handle_get_remote_tags(int r) {
     if (local_tag_data.predecessor.commit_valid &&
         local_tag_data.predecessor.mirror_uuid == m_remote_mirror_uuid &&
         local_tag_data.predecessor.tag_tid > remote_tag.tid) {
-      dout(20) << ": skipping processed predecessor remote tag "
+      dout(15) << ": skipping processed predecessor remote tag "
                << remote_tag.tid << dendl;
       continue;
     }
@@ -569,11 +569,11 @@ void BootstrapRequest<I>::handle_get_remote_tags(int r) {
     if (!local_tag_data.predecessor.commit_valid) {
       // newly synced local image (no predecessor) replays from the first tag
       if (remote_tag_data.mirror_uuid != librbd::Journal<>::LOCAL_MIRROR_UUID) {
-        dout(20) << ": skipping non-primary remote tag" << dendl;
+        dout(15) << ": skipping non-primary remote tag" << dendl;
         continue;
       }
 
-      dout(20) << ": using initial primary remote tag" << dendl;
+      dout(10) << ": using initial primary remote tag" << dendl;
       break;
     }
 
@@ -590,7 +590,7 @@ void BootstrapRequest<I>::handle_get_remote_tags(int r) {
             local_tag_data.predecessor.mirror_uuid ==
               librbd::Journal<>::LOCAL_MIRROR_UUID) {
           // local demoted and remote has matching event
-          dout(20) << ": found matching local demotion tag" << dendl;
+          dout(15) << ": found matching local demotion tag" << dendl;
           remote_orphan_tag_tid = remote_tag.tid;
           continue;
         }
@@ -599,7 +599,7 @@ void BootstrapRequest<I>::handle_get_remote_tags(int r) {
             remote_tag_data.predecessor.mirror_uuid ==
               librbd::Journal<>::LOCAL_MIRROR_UUID) {
           // remote demoted and local has matching event
-          dout(20) << ": found matching remote demotion tag" << dendl;
+          dout(15) << ": found matching remote demotion tag" << dendl;
           remote_orphan_tag_tid = remote_tag.tid;
           continue;
         }
@@ -610,7 +610,7 @@ void BootstrapRequest<I>::handle_get_remote_tags(int r) {
           remote_tag_data.predecessor.commit_valid && remote_orphan_tag_tid &&
           remote_tag_data.predecessor.tag_tid == *remote_orphan_tag_tid) {
         // remote promotion tag chained to remote/local demotion tag
-        dout(20) << ": found chained remote promotion tag" << dendl;
+        dout(15) << ": found chained remote promotion tag" << dendl;
         reconnect_orphan = true;
         break;
       }
@@ -622,9 +622,9 @@ void BootstrapRequest<I>::handle_get_remote_tags(int r) {
 
   if (remote_tag_data_valid &&
       local_tag_data.mirror_uuid == m_remote_mirror_uuid) {
-    dout(20) << ": local image is in clean replay state" << dendl;
+    dout(10) << ": local image is in clean replay state" << dendl;
   } else if (reconnect_orphan) {
-    dout(20) << ": remote image was demoted/promoted" << dendl;
+    dout(10) << ": remote image was demoted/promoted" << dendl;
   } else {
     derr << ": split-brain detected -- skipping image replay" << dendl;
     m_ret_val = -EEXIST;