src/ceph/src/librbd/operation/SnapshotRollbackRequest.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/operation/SnapshotRollbackRequest.h"
   5 #include "include/rados/librados.hpp"
   6 #include "common/dout.h"
   7 #include "common/errno.h"
   8 #include "librbd/AsyncObjectThrottle.h"
   9 #include "librbd/ImageCtx.h"
  10 #include "librbd/ObjectMap.h"
  11 #include "librbd/Utils.h"
  12 #include "librbd/io/ImageRequestWQ.h"
  13 #include "librbd/operation/ResizeRequest.h"
  14 #include "osdc/Striper.h"
  15 #include <boost/lambda/bind.hpp>
  16 #include <boost/lambda/construct.hpp>
  17
  18 #define dout_subsys ceph_subsys_rbd
  19 #undef dout_prefix
  20 #define dout_prefix *_dout << "librbd::SnapshotRollbackRequest: "
  21
  22 namespace librbd {
  23 namespace operation {
  24
  25 using util::create_context_callback;
  26 using util::create_rados_callback;
  27
  28 namespace {
  29
  30 template <typename I>
  31 class C_RollbackObject : public C_AsyncObjectThrottle<I> {
  32 public:
  33   C_RollbackObject(AsyncObjectThrottle<I> &throttle, I *image_ctx,
  34                    uint64_t snap_id, uint64_t object_num)
  35     : C_AsyncObjectThrottle<I>(throttle, *image_ctx), m_snap_id(snap_id),
  36       m_object_num(object_num) {
  37   }
  38
  39   int send() override {
  40     I &image_ctx = this->m_image_ctx;
  41     CephContext *cct = image_ctx.cct;
  42     ldout(cct, 20) << "C_RollbackObject: " << __func__ << ": object_num="
  43                    << m_object_num << dendl;
  44
  45     std::string oid = image_ctx.get_object_name(m_object_num);
  46
  47     librados::ObjectWriteOperation op;
  48     op.selfmanaged_snap_rollback(m_snap_id);
  49
  50     librados::AioCompletion *rados_completion =
  51       util::create_rados_callback(this);
  52     image_ctx.data_ctx.aio_operate(oid, rados_completion, &op);
  53     rados_completion->release();
  54     return 0;
  55   }
  56
  57 private:
  58   uint64_t m_snap_id;
  59   uint64_t m_object_num;
  60 };
  61
  62 } // anonymous namespace
  63
  64 template <typename I>
  65 SnapshotRollbackRequest<I>::SnapshotRollbackRequest(I &image_ctx,
  66                                                     Context *on_finish,
  67                                                     const cls::rbd::SnapshotNamespace &snap_namespace,
  68                                                     const std::string &snap_name,
  69                                                     uint64_t snap_id,
  70                                                     uint64_t snap_size,
  71                                                     ProgressContext &prog_ctx)
  72   : Request<I>(image_ctx, on_finish), m_snap_namespace(snap_namespace),
  73     m_snap_name(snap_name), m_snap_id(snap_id),
  74     m_snap_size(snap_size), m_prog_ctx(prog_ctx), m_object_map(nullptr) {
  75 }
  76
  77 template <typename I>
  78 SnapshotRollbackRequest<I>::~SnapshotRollbackRequest() {
  79   I &image_ctx = this->m_image_ctx;
  80   if (m_blocking_writes) {
  81     image_ctx.io_work_queue->unblock_writes();
  82   }
  83   delete m_object_map;
  84 }
  85
  86 template <typename I>
  87 void SnapshotRollbackRequest<I>::send_op() {
  88   send_block_writes();
  89 }
  90
  91 template <typename I>
  92 void SnapshotRollbackRequest<I>::send_block_writes() {
  93   I &image_ctx = this->m_image_ctx;
  94   CephContext *cct = image_ctx.cct;
  95   ldout(cct, 5) << this << " " << __func__ << dendl;
  96
  97   m_blocking_writes = true;
  98   image_ctx.io_work_queue->block_writes(create_context_callback<
  99     SnapshotRollbackRequest<I>,
 100     &SnapshotRollbackRequest<I>::handle_block_writes>(this));
 101 }
 102
 103 template <typename I>
 104 Context *SnapshotRollbackRequest<I>::handle_block_writes(int *result) {
 105   I &image_ctx = this->m_image_ctx;
 106   CephContext *cct = image_ctx.cct;
 107   ldout(cct, 5) << this << " " << __func__ << ": r=" << *result << dendl;
 108
 109   if (*result < 0) {
 110     lderr(cct) << "failed to block writes: " << cpp_strerror(*result) << dendl;
 111     return this->create_context_finisher(*result);
 112   }
 113
 114   send_resize_image();
 115   return nullptr;
 116 }
 117
 118 template <typename I>
 119 void SnapshotRollbackRequest<I>::send_resize_image() {
 120   I &image_ctx = this->m_image_ctx;
 121
 122   uint64_t current_size;
 123   {
 124     RWLock::RLocker owner_locker(image_ctx.owner_lock);
 125     RWLock::RLocker snap_locker(image_ctx.snap_lock);
 126     current_size = image_ctx.get_image_size(CEPH_NOSNAP);
 127   }
 128
 129   if (current_size == m_snap_size) {
 130     send_rollback_object_map();
 131     return;
 132   }
 133
 134   CephContext *cct = image_ctx.cct;
 135   ldout(cct, 5) << this << " " << __func__ << dendl;
 136
 137   Context *ctx = create_context_callback<
 138     SnapshotRollbackRequest<I>,
 139     &SnapshotRollbackRequest<I>::handle_resize_image>(this);
 140   ResizeRequest<I> *req = ResizeRequest<I>::create(image_ctx, ctx, m_snap_size,
 141                                                    true, m_no_op_prog_ctx, 0, true);
 142   req->send();
 143 }
 144
 145 template <typename I>
 146 Context *SnapshotRollbackRequest<I>::handle_resize_image(int *result) {
 147   I &image_ctx = this->m_image_ctx;
 148   CephContext *cct = image_ctx.cct;
 149   ldout(cct, 5) << this << " " << __func__ << ": r=" << *result << dendl;
 150
 151   if (*result < 0) {
 152     lderr(cct) << "failed to resize image for rollback: "
 153                << cpp_strerror(*result) << dendl;
 154     return this->create_context_finisher(*result);
 155   }
 156
 157   send_rollback_object_map();
 158   return nullptr;
 159 }
 160
 161 template <typename I>
 162 void SnapshotRollbackRequest<I>::send_rollback_object_map() {
 163   I &image_ctx = this->m_image_ctx;
 164
 165   {
 166     RWLock::RLocker owner_locker(image_ctx.owner_lock);
 167     RWLock::RLocker snap_locker(image_ctx.snap_lock);
 168     RWLock::WLocker object_map_lock(image_ctx.object_map_lock);
 169     if (image_ctx.object_map != nullptr) {
 170       CephContext *cct = image_ctx.cct;
 171       ldout(cct, 5) << this << " " << __func__ << dendl;
 172
 173       Context *ctx = create_context_callback<
 174         SnapshotRollbackRequest<I>,
 175         &SnapshotRollbackRequest<I>::handle_rollback_object_map>(this);
 176       image_ctx.object_map->rollback(m_snap_id, ctx);
 177       return;
 178     }
 179   }
 180
 181   send_rollback_objects();
 182 }
 183
 184 template <typename I>
 185 Context *SnapshotRollbackRequest<I>::handle_rollback_object_map(int *result) {
 186   I &image_ctx = this->m_image_ctx;
 187   CephContext *cct = image_ctx.cct;
 188   ldout(cct, 5) << this << " " << __func__ << ": r=" << *result << dendl;
 189
 190   assert(*result == 0);
 191   send_rollback_objects();
 192   return nullptr;
 193 }
 194
 195 template <typename I>
 196 void SnapshotRollbackRequest<I>::send_rollback_objects() {
 197   I &image_ctx = this->m_image_ctx;
 198   CephContext *cct = image_ctx.cct;
 199   ldout(cct, 5) << this << " " << __func__ << dendl;
 200
 201   RWLock::RLocker owner_locker(image_ctx.owner_lock);
 202   uint64_t num_objects;
 203   {
 204     RWLock::RLocker snap_locker(image_ctx.snap_lock);
 205     num_objects = Striper::get_num_objects(image_ctx.layout,
 206                                            image_ctx.get_current_size());
 207   }
 208
 209   Context *ctx = create_context_callback<
 210     SnapshotRollbackRequest<I>,
 211     &SnapshotRollbackRequest<I>::handle_rollback_objects>(this);
 212   typename AsyncObjectThrottle<I>::ContextFactory context_factory(
 213     boost::lambda::bind(boost::lambda::new_ptr<C_RollbackObject<I> >(),
 214       boost::lambda::_1, &image_ctx, m_snap_id, boost::lambda::_2));
 215   AsyncObjectThrottle<I> *throttle = new AsyncObjectThrottle<I>(
 216     this, image_ctx, context_factory, ctx, &m_prog_ctx, 0, num_objects);
 217   throttle->start_ops(image_ctx.concurrent_management_ops);
 218 }
 219
 220 template <typename I>
 221 Context *SnapshotRollbackRequest<I>::handle_rollback_objects(int *result) {
 222   I &image_ctx = this->m_image_ctx;
 223   CephContext *cct = image_ctx.cct;
 224   ldout(cct, 5) << this << " " << __func__ << ": r=" << *result << dendl;
 225
 226   if (*result == -ERESTART) {
 227     ldout(cct, 5) << "snapshot rollback operation interrupted" << dendl;
 228     return this->create_context_finisher(*result);
 229   } else if (*result < 0) {
 230     lderr(cct) << "failed to rollback objects: " << cpp_strerror(*result)
 231                << dendl;
 232     return this->create_context_finisher(*result);
 233   }
 234
 235   return send_refresh_object_map();
 236 }
 237
 238 template <typename I>
 239 Context *SnapshotRollbackRequest<I>::send_refresh_object_map() {
 240   I &image_ctx = this->m_image_ctx;
 241
 242   bool object_map_enabled;
 243   {
 244     RWLock::RLocker owner_locker(image_ctx.owner_lock);
 245     RWLock::RLocker snap_locker(image_ctx.snap_lock);
 246     object_map_enabled = (image_ctx.object_map != nullptr);
 247   }
 248   if (!object_map_enabled) {
 249     return send_invalidate_cache();
 250   }
 251
 252   CephContext *cct = image_ctx.cct;
 253   ldout(cct, 5) << this << " " << __func__ << dendl;
 254
 255   m_object_map = image_ctx.create_object_map(CEPH_NOSNAP);
 256
 257   Context *ctx = create_context_callback<
 258     SnapshotRollbackRequest<I>,
 259     &SnapshotRollbackRequest<I>::handle_refresh_object_map>(this);
 260   m_object_map->open(ctx);
 261   return nullptr;
 262 }
 263
 264 template <typename I>
 265 Context *SnapshotRollbackRequest<I>::handle_refresh_object_map(int *result) {
 266   I &image_ctx = this->m_image_ctx;
 267   CephContext *cct = image_ctx.cct;
 268   ldout(cct, 5) << this << " " << __func__ << ": r=" << *result << dendl;
 269
 270   assert(*result == 0);
 271   return send_invalidate_cache();
 272 }
 273
 274 template <typename I>
 275 Context *SnapshotRollbackRequest<I>::send_invalidate_cache() {
 276   I &image_ctx = this->m_image_ctx;
 277
 278   apply();
 279   if (image_ctx.object_cacher == NULL) {
 280     return this->create_context_finisher(0);
 281   }
 282
 283   CephContext *cct = image_ctx.cct;
 284   ldout(cct, 5) << this << " " << __func__ << dendl;
 285
 286   RWLock::RLocker owner_lock(image_ctx.owner_lock);
 287   Context *ctx = create_context_callback<
 288     SnapshotRollbackRequest<I>,
 289     &SnapshotRollbackRequest<I>::handle_invalidate_cache>(this);
 290   image_ctx.invalidate_cache(true, ctx);
 291   return nullptr;
 292 }
 293
 294 template <typename I>
 295 Context *SnapshotRollbackRequest<I>::handle_invalidate_cache(int *result) {
 296   I &image_ctx = this->m_image_ctx;
 297   CephContext *cct = image_ctx.cct;
 298   ldout(cct, 5) << this << " " << __func__ << ": r=" << *result << dendl;
 299
 300   if (*result < 0) {
 301     lderr(cct) << "failed to invalidate cache: " << cpp_strerror(*result)
 302                << dendl;
 303   }
 304   return this->create_context_finisher(*result);
 305 }
 306
 307 template <typename I>
 308 void SnapshotRollbackRequest<I>::apply() {
 309   I &image_ctx = this->m_image_ctx;
 310
 311   RWLock::RLocker owner_locker(image_ctx.owner_lock);
 312   RWLock::WLocker snap_locker(image_ctx.snap_lock);
 313   if (image_ctx.object_map != nullptr) {
 314     std::swap(m_object_map, image_ctx.object_map);
 315   }
 316 }
 317
 318 } // namespace operation
 319 } // namespace librbd
 320
 321 template class librbd::operation::SnapshotRollbackRequest<librbd::ImageCtx>;