ceph/src/librbd/object_map/UpdateRequest.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/object_map/UpdateRequest.h"
   5 #include "include/rbd/object_map_types.h"
   6 #include "include/stringify.h"
   7 #include "common/dout.h"
   8 #include "librbd/ImageCtx.h"
   9 #include "librbd/ObjectMap.h"
  10 #include "librbd/Utils.h"
  11 #include "cls/lock/cls_lock_client.h"
  12 #include <string>
  13
  14 #define dout_subsys ceph_subsys_rbd
  15 #undef dout_prefix
  16 #define dout_prefix *_dout << "librbd::object_map::UpdateRequest: " << this \
  17                            << " " << __func__ << ": "
  18
  19 namespace librbd {
  20 namespace object_map {
  21
  22 namespace {
  23
  24 // keep aligned to bit_vector 4K block sizes
  25 const uint64_t MAX_OBJECTS_PER_UPDATE = 256 * (1 << 10);
  26
  27 }
  28
  29 template <typename I>
  30 void UpdateRequest<I>::send() {
  31   update_object_map();
  32 }
  33
  34 template <typename I>
  35 void UpdateRequest<I>::update_object_map() {
  36   assert(m_image_ctx.snap_lock.is_locked());
  37   assert(m_image_ctx.object_map_lock.is_locked());
  38   CephContext *cct = m_image_ctx.cct;
  39
  40   // break very large requests into manageable batches
  41   m_update_end_object_no = MIN(
  42     m_end_object_no, m_update_start_object_no + MAX_OBJECTS_PER_UPDATE);
  43
  44   std::string oid(ObjectMap<>::object_map_name(m_image_ctx.id, m_snap_id));
  45   ldout(cct, 20) << "ictx=" << &m_image_ctx << ", oid=" << oid << ", "
  46                  << "[" << m_update_start_object_no << ","
  47                         << m_update_end_object_no << ") = "
  48                  << (m_current_state ?
  49                        stringify(static_cast<uint32_t>(*m_current_state)) : "")
  50                  << "->" << static_cast<uint32_t>(m_new_state)
  51                  << dendl;
  52
  53   librados::ObjectWriteOperation op;
  54   if (m_snap_id == CEPH_NOSNAP) {
  55     rados::cls::lock::assert_locked(&op, RBD_LOCK_NAME, LOCK_EXCLUSIVE, "", "");
  56   }
  57   cls_client::object_map_update(&op, m_update_start_object_no,
  58                                 m_update_end_object_no, m_new_state,
  59                                 m_current_state);
  60
  61   auto rados_completion = librbd::util::create_rados_callback<
  62     UpdateRequest<I>, &UpdateRequest<I>::handle_update_object_map>(this);
  63   std::vector<librados::snap_t> snaps;
  64   int r = m_image_ctx.md_ctx.aio_operate(
  65     oid, rados_completion, &op, 0, snaps,
  66     (m_trace.valid() ? m_trace.get_info() : nullptr));
  67   assert(r == 0);
  68   rados_completion->release();
  69 }
  70
  71 template <typename I>
  72 void UpdateRequest<I>::handle_update_object_map(int r) {
  73   ldout(m_image_ctx.cct, 20) << "r=" << r << dendl;
  74
  75   {
  76     RWLock::RLocker snap_locker(m_image_ctx.snap_lock);
  77     RWLock::WLocker object_map_locker(m_image_ctx.object_map_lock);
  78     update_in_memory_object_map();
  79
  80     if (m_update_end_object_no < m_end_object_no) {
  81       m_update_start_object_no = m_update_end_object_no;
  82       update_object_map();
  83       return;
  84     }
  85   }
  86
  87   // no more batch updates to send
  88   complete(r);
  89 }
  90
  91 template <typename I>
  92 void UpdateRequest<I>::update_in_memory_object_map() {
  93   assert(m_image_ctx.snap_lock.is_locked());
  94   assert(m_image_ctx.object_map_lock.is_locked());
  95
  96   // rebuilding the object map might update on-disk only
  97   if (m_snap_id == m_image_ctx.snap_id) {
  98     ldout(m_image_ctx.cct, 20) << dendl;
  99
 100     auto it = m_object_map.begin() +
 101                     MIN(m_update_start_object_no, m_object_map.size());
 102     auto end_it = m_object_map.begin() +
 103                     MIN(m_update_end_object_no, m_object_map.size());
 104     for (; it != end_it; ++it) {
 105       auto state_ref = *it;
 106       uint8_t state = state_ref;
 107       if (!m_current_state || state == *m_current_state ||
 108           (*m_current_state == OBJECT_EXISTS && state == OBJECT_EXISTS_CLEAN)) {
 109         state_ref = m_new_state;
 110       }
 111     }
 112   }
 113 }
 114
 115 template <typename I>
 116 void UpdateRequest<I>::finish_request() {
 117 }
 118
 119 } // namespace object_map
 120 } // namespace librbd
 121
 122 template class librbd::object_map::UpdateRequest<librbd::ImageCtx>;