ceph/src/librbd/io/ObjectDispatch.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/io/ObjectDispatch.h"
   5 #include "common/dout.h"
   6 #include "librbd/AsioEngine.h"
   7 #include "librbd/ImageCtx.h"
   8 #include "librbd/Utils.h"
   9 #include "librbd/io/ObjectRequest.h"
  10
  11 #define dout_subsys ceph_subsys_rbd
  12 #undef dout_prefix
  13 #define dout_prefix *_dout << "librbd::io::ObjectDispatch: " << this \
  14                            << " " << __func__ << ": "
  15
  16 namespace librbd {
  17 namespace io {
  18
  19 using librbd::util::data_object_name;
  20
  21 template <typename I>
  22 ObjectDispatch<I>::ObjectDispatch(I* image_ctx)
  23   : m_image_ctx(image_ctx) {
  24 }
  25
  26 template <typename I>
  27 void ObjectDispatch<I>::shut_down(Context* on_finish) {
  28   auto cct = m_image_ctx->cct;
  29   ldout(cct, 5) << dendl;
  30
  31   m_image_ctx->asio_engine->post(on_finish, 0);
  32 }
  33
  34 template <typename I>
  35 bool ObjectDispatch<I>::read(
  36     uint64_t object_no, ReadExtents* extents, IOContext io_context,
  37     int op_flags, int read_flags, const ZTracer::Trace &parent_trace,
  38     uint64_t* version, int* object_dispatch_flags,
  39     DispatchResult* dispatch_result, Context** on_finish,
  40     Context* on_dispatched) {
  41   auto cct = m_image_ctx->cct;
  42   ldout(cct, 20) << "object_no=" << object_no << " " << *extents << dendl;
  43
  44   *dispatch_result = DISPATCH_RESULT_COMPLETE;
  45   auto req = new ObjectReadRequest<I>(m_image_ctx, object_no, extents,
  46                                       io_context, op_flags, read_flags,
  47                                       parent_trace, version, on_dispatched);
  48   req->send();
  49   return true;
  50 }
  51
  52 template <typename I>
  53 bool ObjectDispatch<I>::discard(
  54     uint64_t object_no, uint64_t object_off, uint64_t object_len,
  55     IOContext io_context, int discard_flags,
  56     const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
  57     uint64_t* journal_tid, DispatchResult* dispatch_result,
  58     Context** on_finish, Context* on_dispatched) {
  59   auto cct = m_image_ctx->cct;
  60   ldout(cct, 20) << data_object_name(m_image_ctx, object_no) << " "
  61                  << object_off << "~" << object_len << dendl;
  62
  63   *dispatch_result = DISPATCH_RESULT_COMPLETE;
  64   auto req = new ObjectDiscardRequest<I>(m_image_ctx, object_no, object_off,
  65                                          object_len, io_context, discard_flags,
  66                                          parent_trace, on_dispatched);
  67   req->send();
  68   return true;
  69 }
  70
  71 template <typename I>
  72 bool ObjectDispatch<I>::write(
  73     uint64_t object_no, uint64_t object_off, ceph::bufferlist&& data,
  74     IOContext io_context, int op_flags, int write_flags,
  75     std::optional<uint64_t> assert_version,
  76     const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
  77     uint64_t* journal_tid, DispatchResult* dispatch_result,
  78     Context** on_finish, Context* on_dispatched) {
  79   auto cct = m_image_ctx->cct;
  80   ldout(cct, 20) << data_object_name(m_image_ctx, object_no) << " "
  81                  << object_off << "~" << data.length() << dendl;
  82
  83   *dispatch_result = DISPATCH_RESULT_COMPLETE;
  84   auto req = new ObjectWriteRequest<I>(m_image_ctx, object_no, object_off,
  85                                        std::move(data), io_context, op_flags,
  86                                        write_flags, assert_version,
  87                                        parent_trace, on_dispatched);
  88   req->send();
  89   return true;
  90 }
  91
  92 template <typename I>
  93 bool ObjectDispatch<I>::write_same(
  94     uint64_t object_no, uint64_t object_off, uint64_t object_len,
  95     LightweightBufferExtents&& buffer_extents, ceph::bufferlist&& data,
  96     IOContext io_context, int op_flags,
  97     const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
  98     uint64_t* journal_tid, DispatchResult* dispatch_result,
  99     Context** on_finish, Context* on_dispatched) {
 100   auto cct = m_image_ctx->cct;
 101   ldout(cct, 20) << data_object_name(m_image_ctx, object_no) << " "
 102                  << object_off << "~" << object_len << dendl;
 103
 104   *dispatch_result = DISPATCH_RESULT_COMPLETE;
 105   auto req = new ObjectWriteSameRequest<I>(m_image_ctx, object_no,
 106                                            object_off, object_len,
 107                                            std::move(data), io_context,
 108                                            op_flags, parent_trace,
 109                                            on_dispatched);
 110   req->send();
 111   return true;
 112 }
 113
 114 template <typename I>
 115 bool ObjectDispatch<I>::compare_and_write(
 116     uint64_t object_no, uint64_t object_off, ceph::bufferlist&& cmp_data,
 117     ceph::bufferlist&& write_data, IOContext io_context, int op_flags,
 118     const ZTracer::Trace &parent_trace, uint64_t* mismatch_offset,
 119     int* object_dispatch_flags, uint64_t* journal_tid,
 120     DispatchResult* dispatch_result, Context** on_finish,
 121     Context* on_dispatched) {
 122   auto cct = m_image_ctx->cct;
 123   ldout(cct, 20) << data_object_name(m_image_ctx, object_no) << " "
 124                  << object_off << "~" << write_data.length() << dendl;
 125
 126   *dispatch_result = DISPATCH_RESULT_COMPLETE;
 127   auto req = new ObjectCompareAndWriteRequest<I>(m_image_ctx, object_no,
 128                                                  object_off,
 129                                                  std::move(cmp_data),
 130                                                  std::move(write_data),
 131                                                  io_context, mismatch_offset,
 132                                                  op_flags, parent_trace,
 133                                                  on_dispatched);
 134   req->send();
 135   return true;
 136 }
 137
 138 template <typename I>
 139 bool ObjectDispatch<I>::list_snaps(
 140     uint64_t object_no, io::Extents&& extents, SnapIds&& snap_ids,
 141     int list_snap_flags, const ZTracer::Trace &parent_trace,
 142     SnapshotDelta* snapshot_delta, int* object_dispatch_flags,
 143     DispatchResult* dispatch_result, Context** on_finish,
 144     Context* on_dispatched) {
 145   auto cct = m_image_ctx->cct;
 146   ldout(cct, 20) << data_object_name(m_image_ctx, object_no) << " "
 147                  << "extents=" << extents << ", "
 148                  << "snap_ids=" << snap_ids << dendl;
 149
 150   *dispatch_result = DISPATCH_RESULT_COMPLETE;
 151   auto req = ObjectListSnapsRequest<I>::create(
 152     m_image_ctx, object_no, std::move(extents), std::move(snap_ids),
 153     list_snap_flags, parent_trace, snapshot_delta, on_dispatched);
 154   req->send();
 155   return true;
 156 }
 157
 158 } // namespace io
 159 } // namespace librbd
 160
 161 template class librbd::io::ObjectDispatch<librbd::ImageCtx>;