ceph/src/librbd/journal/ResetRequest.cc

   1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
   2 // vim: ts=8 sw=2 smarttab
   3
   4 #include "librbd/journal/ResetRequest.h"
   5 #include "common/dout.h"
   6 #include "common/errno.h"
   7 #include "common/Timer.h"
   8 #include "common/WorkQueue.h"
   9 #include "journal/Journaler.h"
  10 #include "journal/Settings.h"
  11 #include "include/ceph_assert.h"
  12 #include "librbd/Journal.h"
  13 #include "librbd/Utils.h"
  14 #include "librbd/journal/CreateRequest.h"
  15 #include "librbd/journal/RemoveRequest.h"
  16
  17 #define dout_subsys ceph_subsys_rbd
  18 #undef dout_prefix
  19 #define dout_prefix *_dout << "librbd::journal::ResetRequest: " << this << " " \
  20                            << __func__ << ": "
  21
  22 namespace librbd {
  23 namespace journal {
  24
  25 using util::create_async_context_callback;
  26 using util::create_context_callback;
  27
  28 template<typename I>
  29 void ResetRequest<I>::send() {
  30    init_journaler();
  31 }
  32
  33 template<typename I>
  34 void ResetRequest<I>::init_journaler() {
  35   ldout(m_cct, 10) << dendl;
  36
  37   m_journaler = new Journaler(m_io_ctx, m_image_id, m_client_id, {}, nullptr);
  38   Context *ctx = create_context_callback<
  39      ResetRequest<I>, &ResetRequest<I>::handle_init_journaler>(this);
  40   m_journaler->init(ctx);
  41 }
  42
  43 template<typename I>
  44 void ResetRequest<I>::handle_init_journaler(int r) {
  45   ldout(m_cct, 10) << "r=" << r << dendl;
  46
  47   if (r == -ENOENT) {
  48     ldout(m_cct, 5) << "journal does not exist" << dendl;
  49     m_ret_val = r;
  50   } else if (r < 0) {
  51     lderr(m_cct) << "failed to init journaler: " << cpp_strerror(r) << dendl;
  52     m_ret_val = r;
  53   } else {
  54     int64_t pool_id;
  55     m_journaler->get_metadata(&m_order, &m_splay_width, &pool_id);
  56
  57     if (pool_id != -1) {
  58       librados::Rados rados(m_io_ctx);
  59       r = rados.pool_reverse_lookup(pool_id, &m_object_pool_name);
  60       if (r < 0) {
  61         lderr(m_cct) << "failed to lookup data pool: " << cpp_strerror(r)
  62                      << dendl;
  63         m_ret_val = r;
  64       }
  65     }
  66   }
  67
  68   shut_down_journaler();
  69 }
  70
  71 template<typename I>
  72 void ResetRequest<I>::shut_down_journaler() {
  73   ldout(m_cct, 10) << dendl;
  74
  75   Context *ctx = create_async_context_callback(
  76     m_op_work_queue, create_context_callback<
  77       ResetRequest<I>, &ResetRequest<I>::handle_journaler_shutdown>(this));
  78   m_journaler->shut_down(ctx);
  79 }
  80
  81 template<typename I>
  82 void ResetRequest<I>::handle_journaler_shutdown(int r) {
  83   ldout(m_cct, 10) << "r=" << r << dendl;
  84
  85   delete m_journaler;
  86   if (r < 0) {
  87     lderr(m_cct) << "failed to shut down journaler: " << cpp_strerror(r)
  88                  << dendl;
  89     if (m_ret_val == 0) {
  90       m_ret_val = r;
  91     }
  92   }
  93
  94   if (m_ret_val < 0) {
  95     finish(m_ret_val);
  96     return;
  97   }
  98
  99   remove_journal();
 100 }
 101
 102 template<typename I>
 103 void ResetRequest<I>::remove_journal() {
 104   ldout(m_cct, 10) << dendl;
 105
 106   Context *ctx = create_context_callback<
 107     ResetRequest<I>, &ResetRequest<I>::handle_remove_journal>(this);
 108   auto req = RemoveRequest<I>::create(m_io_ctx, m_image_id, m_client_id,
 109                                       m_op_work_queue, ctx);
 110   req->send();
 111 }
 112
 113 template<typename I>
 114 void ResetRequest<I>::handle_remove_journal(int r) {
 115   ldout(m_cct, 10) << "r=" << r << dendl;
 116
 117   if (r < 0) {
 118     lderr(m_cct) << "failed to remove journal: " << cpp_strerror(r) << dendl;
 119     finish(r);
 120     return;
 121   }
 122
 123   create_journal();
 124 }
 125
 126 template<typename I>
 127 void ResetRequest<I>::create_journal() {
 128   ldout(m_cct, 10) << dendl;
 129
 130   Context *ctx = create_context_callback<
 131     ResetRequest<I>, &ResetRequest<I>::handle_create_journal>(this);
 132   journal::TagData tag_data(m_mirror_uuid);
 133   auto req = CreateRequest<I>::create(m_io_ctx, m_image_id, m_order,
 134                                       m_splay_width, m_object_pool_name,
 135                                       cls::journal::Tag::TAG_CLASS_NEW,
 136                                       tag_data, m_client_id, m_op_work_queue,
 137                                       ctx);
 138   req->send();
 139 }
 140
 141 template<typename I>
 142 void ResetRequest<I>::handle_create_journal(int r) {
 143   ldout(m_cct, 10) << "r=" << r << dendl;
 144
 145   if (r < 0) {
 146     lderr(m_cct) << "failed to create journal: " << cpp_strerror(r) << dendl;
 147   }
 148   finish(r);
 149 }
 150
 151 template<typename I>
 152 void ResetRequest<I>::finish(int r) {
 153    ldout(m_cct, 10) << "r=" << r << dendl;
 154
 155    m_on_finish->complete(r);
 156    delete this;
 157 }
 158
 159 } // namespace journal
 160 } // namespace librbd
 161
 162 template class librbd::journal::ResetRequest<librbd::ImageCtx>;