src/ceph/src/librbd/journal/OpenRequest.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/OpenRequest.h"
   5 #include "common/dout.h"
   6 #include "common/errno.h"
   7 #include "common/WorkQueue.h"
   8 #include "journal/Journaler.h"
   9 #include "librbd/ImageCtx.h"
  10 #include "librbd/Journal.h"
  11 #include "librbd/Utils.h"
  12 #include "librbd/journal/Types.h"
  13 #include "librbd/journal/Utils.h"
  14
  15 #define dout_subsys ceph_subsys_rbd
  16 #undef dout_prefix
  17 #define dout_prefix *_dout << "librbd::journal::OpenRequest: " << this << " " \
  18                            << __func__ << ": "
  19
  20 namespace librbd {
  21 namespace journal {
  22
  23 using librbd::util::create_async_context_callback;
  24 using librbd::util::create_context_callback;
  25 using util::C_DecodeTags;
  26
  27 template <typename I>
  28 OpenRequest<I>::OpenRequest(I *image_ctx, Journaler *journaler, Mutex *lock,
  29                             journal::ImageClientMeta *client_meta,
  30                             uint64_t *tag_tid, journal::TagData *tag_data,
  31                             Context *on_finish)
  32   : m_image_ctx(image_ctx), m_journaler(journaler), m_lock(lock),
  33     m_client_meta(client_meta), m_tag_tid(tag_tid), m_tag_data(tag_data),
  34     m_on_finish(on_finish) {
  35 }
  36
  37 template <typename I>
  38 void OpenRequest<I>::send() {
  39   send_init();
  40 }
  41
  42 template <typename I>
  43 void OpenRequest<I>::send_init() {
  44   CephContext *cct = m_image_ctx->cct;
  45   ldout(cct, 20) << dendl;
  46
  47   m_journaler->init(create_async_context_callback(
  48     *m_image_ctx, create_context_callback<
  49       OpenRequest<I>, &OpenRequest<I>::handle_init>(this)));
  50 }
  51
  52 template <typename I>
  53 void OpenRequest<I>::handle_init(int r) {
  54   CephContext *cct = m_image_ctx->cct;
  55   ldout(cct, 20) << "r=" << r << dendl;
  56
  57   if (r < 0) {
  58     lderr(cct) << "failed to initialize journal: " << cpp_strerror(r)
  59                << dendl;
  60     finish(r);
  61     return;
  62   }
  63
  64   // locate the master image client record
  65   cls::journal::Client client;
  66   r = m_journaler->get_cached_client(Journal<ImageCtx>::IMAGE_CLIENT_ID,
  67                                      &client);
  68   if (r < 0) {
  69     lderr(cct) << "failed to locate master image client" << dendl;
  70     finish(r);
  71     return;
  72   }
  73
  74   librbd::journal::ClientData client_data;
  75   bufferlist::iterator bl = client.data.begin();
  76   try {
  77     ::decode(client_data, bl);
  78   } catch (const buffer::error &err) {
  79     lderr(cct) << "failed to decode client meta data: " << err.what()
  80                << dendl;
  81     finish(-EINVAL);
  82     return;
  83   }
  84
  85   journal::ImageClientMeta *image_client_meta =
  86     boost::get<journal::ImageClientMeta>(&client_data.client_meta);
  87   if (image_client_meta == nullptr) {
  88     lderr(cct) << this << " " << __func__ << ": "
  89                << "failed to extract client meta data" << dendl;
  90     finish(-EINVAL);
  91     return;
  92   }
  93
  94   ldout(cct, 20) << this << " " << __func__ << ": "
  95                  << "client: " << client << ", "
  96                  << "image meta: " << *image_client_meta << dendl;
  97
  98   m_tag_class = image_client_meta->tag_class;
  99   {
 100     Mutex::Locker locker(*m_lock);
 101     *m_client_meta = *image_client_meta;
 102   }
 103
 104   send_get_tags();
 105 }
 106
 107 template <typename I>
 108 void OpenRequest<I>::send_get_tags() {
 109   CephContext *cct = m_image_ctx->cct;
 110   ldout(cct, 20) << dendl;
 111
 112   C_DecodeTags *tags_ctx = new C_DecodeTags(
 113     cct, m_lock, m_tag_tid, m_tag_data, create_async_context_callback(
 114       *m_image_ctx, create_context_callback<
 115         OpenRequest<I>, &OpenRequest<I>::handle_get_tags>(this)));
 116   m_journaler->get_tags(m_tag_class, &tags_ctx->tags, tags_ctx);
 117 }
 118
 119 template <typename I>
 120 void OpenRequest<I>::handle_get_tags(int r) {
 121   CephContext *cct = m_image_ctx->cct;
 122   ldout(cct, 20) << "r=" << r << dendl;
 123
 124   if (r < 0) {
 125     lderr(cct) << this << " " << __func__ << ": "
 126                << "failed to decode journal tags: " << cpp_strerror(r) << dendl;
 127   }
 128
 129   finish(r);
 130 }
 131
 132 template <typename I>
 133 void OpenRequest<I>::finish(int r) {
 134   CephContext *cct = m_image_ctx->cct;
 135   ldout(cct, 20) << "r=" << r << dendl;
 136
 137   m_on_finish->complete(r);
 138   delete this;
 139 }
 140
 141 } // namespace journal
 142 } // namespace librbd
 143
 144 template class librbd::journal::OpenRequest<librbd::ImageCtx>;