librbd: propagate area down to file_to_extents()

- readahead and PWL cache are limited to DATA area as explained in
  the previous commit
- DATA area is assumed for the journal as encryption can't be used
  with journaling anyway

To postpone the churn associated with passing area through
ImageDispatchInterface (where only WriteLogImageDispatch and
ImageDispatch care), add a new image dispatch flag.

Signed-off-by: Ilya Dryomov <idryomov@gmail.com>

diff --git a/src/librbd/cache/WriteLogImageDispatch.cc b/src/librbd/cache/WriteLogImageDispatch.cc
index 6cb8738e7f9efcc6d1486fb121189aa3c08453f6..07b1422f379039d8fbf7ea8156dba87ab7237139 100644 (file)
--- a/src/librbd/cache/WriteLogImageDispatch.cc
+++ b/src/librbd/cache/WriteLogImageDispatch.cc
@@ -42,6 +42,10 @@ bool WriteLogImageDispatch<I>::read(
     std::atomic<uint32_t>* image_dispatch_flags,
     io::DispatchResult* dispatch_result,
     Context** on_finish, Context* on_dispatched) {
+  if (*image_dispatch_flags & io::IMAGE_DISPATCH_FLAG_CRYPTO_HEADER) {
+    return false;
+  }
+
   auto cct = m_image_ctx->cct;
   ldout(cct, 20) << "image_extents=" << image_extents << dendl;
 
@@ -71,6 +75,10 @@ bool WriteLogImageDispatch<I>::write(
     uint64_t tid, std::atomic<uint32_t>* image_dispatch_flags,
     io::DispatchResult* dispatch_result,
     Context** on_finish, Context* on_dispatched) {
+  if (*image_dispatch_flags & io::IMAGE_DISPATCH_FLAG_CRYPTO_HEADER) {
+    return false;
+  }
+
   auto cct = m_image_ctx->cct;
   ldout(cct, 20) << "image_extents=" << image_extents << dendl;
 
@@ -94,6 +102,10 @@ bool WriteLogImageDispatch<I>::discard(
     uint64_t tid, std::atomic<uint32_t>* image_dispatch_flags,
     io::DispatchResult* dispatch_result,
     Context** on_finish, Context* on_dispatched) {
+  if (*image_dispatch_flags & io::IMAGE_DISPATCH_FLAG_CRYPTO_HEADER) {
+    return false;
+  }
+
   auto cct = m_image_ctx->cct;
   ldout(cct, 20) << "image_extents=" << image_extents << dendl;
 
@@ -120,6 +132,10 @@ bool WriteLogImageDispatch<I>::write_same(
     std::atomic<uint32_t>* image_dispatch_flags,
     io::DispatchResult* dispatch_result,
     Context** on_finish, Context* on_dispatched) {
+  if (*image_dispatch_flags & io::IMAGE_DISPATCH_FLAG_CRYPTO_HEADER) {
+    return false;
+  }
+
   auto cct = m_image_ctx->cct;
   ldout(cct, 20) << "image_extents=" << image_extents << dendl;
 
@@ -146,6 +162,10 @@ bool WriteLogImageDispatch<I>::compare_and_write(
     std::atomic<uint32_t>* image_dispatch_flags,
     io::DispatchResult* dispatch_result,
     Context** on_finish, Context* on_dispatched) {
+  if (*image_dispatch_flags & io::IMAGE_DISPATCH_FLAG_CRYPTO_HEADER) {
+    return false;
+  }
+
   auto cct = m_image_ctx->cct;
   ldout(cct, 20) << "image_extents=" << image_extents << dendl;
 

diff --git a/src/librbd/deep_copy/ObjectCopyRequest.cc b/src/librbd/deep_copy/ObjectCopyRequest.cc
index c5b7a9674041ead6f3d1ae524fbc691ac714b847..8fa325aaea286eceed5405452f77e16bcf9ef131 100644 (file)
--- a/src/librbd/deep_copy/ObjectCopyRequest.cc
+++ b/src/librbd/deep_copy/ObjectCopyRequest.cc
@@ -603,8 +603,9 @@ void ObjectCopyRequest<I>::merge_write_ops() {
     for (auto [image_offset, image_length] : read_op.image_extent_map) {
       // convert image extents back to object extents for the write op
       striper::LightweightObjectExtents object_extents;
-      io::util::file_to_extents(m_dst_image_ctx, image_offset,
-                                image_length, buffer_offset, &object_extents);
+      io::util::area_to_object_extents(m_dst_image_ctx, image_offset,
+                                       image_length, m_image_area,
+                                       buffer_offset, &object_extents);
       for (auto& object_extent : object_extents) {
         ldout(m_cct, 20) << "src_snap_seq=" << src_snap_seq << ", "
                          << "object_offset=" << object_extent.offset << ", "
@@ -759,8 +760,9 @@ void ObjectCopyRequest<I>::compute_zero_ops() {
     for (auto z = zero_interval.begin(); z != zero_interval.end(); ++z) {
       // convert image extents back to object extents for the write op
       striper::LightweightObjectExtents object_extents;
-      io::util::file_to_extents(m_dst_image_ctx, z.get_start(), z.get_len(), 0,
-                                &object_extents);
+      io::util::area_to_object_extents(m_dst_image_ctx, z.get_start(),
+                                       z.get_len(), m_image_area, 0,
+                                       &object_extents);
       for (auto& object_extent : object_extents) {
         ceph_assert(object_extent.offset + object_extent.length <=
                       m_dst_image_ctx->layout.object_size);

diff --git a/src/librbd/io/CopyupRequest.cc b/src/librbd/io/CopyupRequest.cc
index 3373fed3b2c55ea6ffe36bbc5709b43128221fa4..220566c64cc5629f17bf7ca5a277dcb68416e3c2 100644 (file)
--- a/src/librbd/io/CopyupRequest.cc
+++ b/src/librbd/io/CopyupRequest.cc
@@ -179,9 +179,9 @@ void CopyupRequest<I>::read_from_parent() {
     &CopyupRequest<I>::handle_read_from_parent>(
       this, librbd::util::get_image_ctx(m_image_ctx->parent), AIO_TYPE_READ);
 
-  ldout(cct, 20) << "completion=" << comp << ", "
-                 << "extents=" << m_image_extents
-                 << dendl;
+  ldout(cct, 20) << "completion=" << comp
+                 << " image_extents=" << m_image_extents
+                 << " area=" << m_image_area << dendl;
   auto req = io::ImageDispatchSpec::create_read(
     *m_image_ctx->parent, io::IMAGE_DISPATCH_LAYER_INTERNAL_START, comp,
     std::move(m_image_extents), m_image_area,
@@ -677,8 +677,8 @@ void CopyupRequest<I>::convert_copyup_extent_map() {
   // convert the image-extent extent map to object-extents
   for (auto [image_offset, image_length] : image_extent_map) {
     striper::LightweightObjectExtents object_extents;
-    util::file_to_extents(
-      m_image_ctx, image_offset, image_length, 0, &object_extents);
+    util::area_to_object_extents(m_image_ctx, image_offset, image_length,
+                                 m_image_area, 0, &object_extents);
     for (auto& object_extent : object_extents) {
       m_copyup_extent_map.emplace_back(
         object_extent.offset, object_extent.length);

diff --git a/src/librbd/io/ImageDispatch.cc b/src/librbd/io/ImageDispatch.cc
index cc8519abeeeb88193f1811f6a21157a93f1b331e..ed3cc357077fcc1c923c2619fb3409903786bddc 100644 (file)
--- a/src/librbd/io/ImageDispatch.cc
+++ b/src/librbd/io/ImageDispatch.cc
@@ -25,6 +25,11 @@ void start_in_flight_io(AioCompletion* aio_comp) {
   }
 }
 
+ImageArea get_area(const std::atomic<uint32_t>* image_dispatch_flags) {
+  return (*image_dispatch_flags & IMAGE_DISPATCH_FLAG_CRYPTO_HEADER ?
+      ImageArea::CRYPTO_HEADER : ImageArea::DATA);
+}
+
 } // anonymous namespace
 
 template <typename I>
@@ -41,14 +46,16 @@ bool ImageDispatch<I>::read(
     DispatchResult* dispatch_result, Context** on_finish,
     Context* on_dispatched) {
   auto cct = m_image_ctx->cct;
-  ldout(cct, 20) << "image_extents=" << image_extents << dendl;
+  auto area = get_area(image_dispatch_flags);
+  ldout(cct, 20) << "image_extents=" << image_extents
+                 << " area=" << area << dendl;
 
   start_in_flight_io(aio_comp);
 
   *dispatch_result = DISPATCH_RESULT_COMPLETE;
-  ImageRequest<I>::aio_read(
-    m_image_ctx, aio_comp, std::move(image_extents), std::move(read_result),
-    io_context, op_flags, read_flags, parent_trace);
+  ImageRequest<I>::aio_read(m_image_ctx, aio_comp, std::move(image_extents),
+                            area, std::move(read_result), io_context, op_flags,
+                            read_flags, parent_trace);
   return true;
 }
 
@@ -60,14 +67,16 @@ bool ImageDispatch<I>::write(
     DispatchResult* dispatch_result, Context** on_finish,
     Context* on_dispatched) {
   auto cct = m_image_ctx->cct;
-  ldout(cct, 20) << "image_extents=" << image_extents << dendl;
+  auto area = get_area(image_dispatch_flags);
+  ldout(cct, 20) << "image_extents=" << image_extents
+                 << " area=" << area << dendl;
 
   start_in_flight_io(aio_comp);
 
   *dispatch_result = DISPATCH_RESULT_COMPLETE;
-  ImageRequest<I>::aio_write(
-    m_image_ctx, aio_comp, std::move(image_extents), std::move(bl),
-    io_context, op_flags, parent_trace);
+  ImageRequest<I>::aio_write(m_image_ctx, aio_comp, std::move(image_extents),
+                             area, std::move(bl), io_context, op_flags,
+                             parent_trace);
   return true;
 }
 
@@ -80,14 +89,16 @@ bool ImageDispatch<I>::discard(
     DispatchResult* dispatch_result, Context** on_finish,
     Context* on_dispatched) {
   auto cct = m_image_ctx->cct;
-  ldout(cct, 20) << "image_extents=" << image_extents << dendl;
+  auto area = get_area(image_dispatch_flags);
+  ldout(cct, 20) << "image_extents=" << image_extents
+                 << " area=" << area << dendl;
 
   start_in_flight_io(aio_comp);
 
   *dispatch_result = DISPATCH_RESULT_COMPLETE;
-  ImageRequest<I>::aio_discard(
-    m_image_ctx, aio_comp, std::move(image_extents), discard_granularity_bytes,
-    io_context, parent_trace);
+  ImageRequest<I>::aio_discard(m_image_ctx, aio_comp, std::move(image_extents),
+                               area, discard_granularity_bytes, io_context,
+                               parent_trace);
   return true;
 }
 
@@ -99,14 +110,16 @@ bool ImageDispatch<I>::write_same(
     DispatchResult* dispatch_result, Context** on_finish,
     Context* on_dispatched) {
   auto cct = m_image_ctx->cct;
-  ldout(cct, 20) << "image_extents=" << image_extents << dendl;
+  auto area = get_area(image_dispatch_flags);
+  ldout(cct, 20) << "image_extents=" << image_extents
+                 << " area=" << area << dendl;
 
   start_in_flight_io(aio_comp);
 
   *dispatch_result = DISPATCH_RESULT_COMPLETE;
-  ImageRequest<I>::aio_writesame(
-    m_image_ctx, aio_comp, std::move(image_extents), std::move(bl),
-    io_context, op_flags, parent_trace);
+  ImageRequest<I>::aio_writesame(m_image_ctx, aio_comp,
+                                 std::move(image_extents), area, std::move(bl),
+                                 io_context, op_flags, parent_trace);
   return true;
 }
 
@@ -119,14 +132,18 @@ bool ImageDispatch<I>::compare_and_write(
     DispatchResult* dispatch_result, Context** on_finish,
     Context* on_dispatched) {
   auto cct = m_image_ctx->cct;
-  ldout(cct, 20) << "image_extents=" << image_extents << dendl;
+  auto area = get_area(image_dispatch_flags);
+  ldout(cct, 20) << "image_extents=" << image_extents
+                 << " area=" << area << dendl;
 
   start_in_flight_io(aio_comp);
 
   *dispatch_result = DISPATCH_RESULT_COMPLETE;
-  ImageRequest<I>::aio_compare_and_write(
-    m_image_ctx, aio_comp, std::move(image_extents), std::move(cmp_bl),
-    std::move(bl), mismatch_offset, io_context, op_flags, parent_trace);
+  ImageRequest<I>::aio_compare_and_write(m_image_ctx, aio_comp,
+                                         std::move(image_extents), area,
+                                         std::move(cmp_bl), std::move(bl),
+                                         mismatch_offset, io_context, op_flags,
+                                         parent_trace);
   return true;
 }
 
@@ -156,14 +173,16 @@ bool ImageDispatch<I>::list_snaps(
     DispatchResult* dispatch_result, Context** on_finish,
     Context* on_dispatched) {
   auto cct = m_image_ctx->cct;
-  ldout(cct, 20) << dendl;
+  auto area = get_area(image_dispatch_flags);
+  ldout(cct, 20) << "image_extents=" << image_extents
+                 << " area=" << area << dendl;
 
   start_in_flight_io(aio_comp);
 
   *dispatch_result = DISPATCH_RESULT_COMPLETE;
-  ImageListSnapsRequest<I> req(
-    *m_image_ctx, aio_comp, std::move(image_extents), std::move(snap_ids),
-    list_snaps_flags, snapshot_delta, parent_trace);
+  ImageListSnapsRequest<I> req(*m_image_ctx, aio_comp, std::move(image_extents),
+                               area, std::move(snap_ids), list_snaps_flags,
+                               snapshot_delta, parent_trace);
   req.send();
   return true;
 }

diff --git a/src/librbd/io/ImageDispatchSpec.h b/src/librbd/io/ImageDispatchSpec.h
index 81bb3eeae0731e38fb1f1b88d210bd84aee1de9e..8e2c452735a53095e140f0f4c269dd881611d53a 100644 (file)
--- a/src/librbd/io/ImageDispatchSpec.h
+++ b/src/librbd/io/ImageDispatchSpec.h
@@ -238,6 +238,16 @@ private:
     ceph_assert(aio_comp->image_dispatcher_ctx == nullptr);
     aio_comp->image_dispatcher_ctx = &dispatcher_ctx;
     aio_comp->get();
+
+    switch (area) {
+    case ImageArea::DATA:
+      break;
+    case ImageArea::CRYPTO_HEADER:
+      image_dispatch_flags |= IMAGE_DISPATCH_FLAG_CRYPTO_HEADER;
+      break;
+    default:
+      ceph_abort();
+    }
   }
 };
 

diff --git a/src/librbd/io/ImageRequest.cc b/src/librbd/io/ImageRequest.cc
index 5b897a5ba209b899673bdd50e30d98a6c3c1af3d..c7f09ef87ac146f0dd66c5098ac9e38dc1436ae6 100644 (file)
--- a/src/librbd/io/ImageRequest.cc
+++ b/src/librbd/io/ImageRequest.cc
@@ -156,8 +156,9 @@ void readahead(I *ictx, const Extents& image_extents, IOContext io_context) {
     ldout(ictx->cct, 20) << "(readahead logical) " << readahead_offset << "~"
                          << readahead_length << dendl;
     LightweightObjectExtents readahead_object_extents;
-    io::util::file_to_extents(ictx, readahead_offset, readahead_length, 0,
-                              &readahead_object_extents);
+    io::util::area_to_object_extents(ictx, readahead_offset, readahead_length,
+                                     ImageArea::DATA, 0,
+                                     &readahead_object_extents);
     for (auto& object_extent : readahead_object_extents) {
       ldout(ictx->cct, 20) << "(readahead) "
                            << data_object_name(ictx,
@@ -227,11 +228,11 @@ bool should_update_timestamp(const utime_t& now, const utime_t& timestamp,
 
 template <typename I>
 void ImageRequest<I>::aio_read(I *ictx, AioCompletion *c,
-                               Extents &&image_extents,
+                               Extents &&image_extents, ImageArea area,
                                ReadResult &&read_result, IOContext io_context,
                                int op_flags, int read_flags,
                               const ZTracer::Trace &parent_trace) {
-  ImageReadRequest<I> req(*ictx, c, std::move(image_extents),
+  ImageReadRequest<I> req(*ictx, c, std::move(image_extents), area,
                           std::move(read_result), io_context, op_flags,
                           read_flags, parent_trace);
   req.send();
@@ -239,21 +240,22 @@ void ImageRequest<I>::aio_read(I *ictx, AioCompletion *c,
 
 template <typename I>
 void ImageRequest<I>::aio_write(I *ictx, AioCompletion *c,
-                                Extents &&image_extents, bufferlist &&bl,
-                                IOContext io_context, int op_flags,
+                                Extents &&image_extents, ImageArea area,
+                                bufferlist &&bl, IOContext io_context,
+                                int op_flags,
                                const ZTracer::Trace &parent_trace) {
-  ImageWriteRequest<I> req(*ictx, c, std::move(image_extents), std::move(bl),
-                           io_context, op_flags, parent_trace);
+  ImageWriteRequest<I> req(*ictx, c, std::move(image_extents), area,
+                           std::move(bl), io_context, op_flags, parent_trace);
   req.send();
 }
 
 template <typename I>
 void ImageRequest<I>::aio_discard(I *ictx, AioCompletion *c,
-                                  Extents &&image_extents,
+                                  Extents &&image_extents, ImageArea area,
                                   uint32_t discard_granularity_bytes,
                                  IOContext io_context,
                                   const ZTracer::Trace &parent_trace) {
-  ImageDiscardRequest<I> req(*ictx, c, std::move(image_extents),
+  ImageDiscardRequest<I> req(*ictx, c, std::move(image_extents), area,
                              discard_granularity_bytes, io_context,
                              parent_trace);
   req.send();
@@ -269,11 +271,11 @@ void ImageRequest<I>::aio_flush(I *ictx, AioCompletion *c,
 
 template <typename I>
 void ImageRequest<I>::aio_writesame(I *ictx, AioCompletion *c,
-                                    Extents &&image_extents,
+                                    Extents &&image_extents, ImageArea area,
                                     bufferlist &&bl, IOContext io_context,
                                     int op_flags,
                                    const ZTracer::Trace &parent_trace) {
-  ImageWriteSameRequest<I> req(*ictx, c, std::move(image_extents),
+  ImageWriteSameRequest<I> req(*ictx, c, std::move(image_extents), area,
                                std::move(bl), io_context, op_flags,
                                parent_trace);
   req.send();
@@ -282,12 +284,13 @@ void ImageRequest<I>::aio_writesame(I *ictx, AioCompletion *c,
 template <typename I>
 void ImageRequest<I>::aio_compare_and_write(I *ictx, AioCompletion *c,
                                             Extents &&image_extents,
+                                            ImageArea area,
                                             bufferlist &&cmp_bl,
                                             bufferlist &&bl,
                                             uint64_t *mismatch_offset,
                                             IOContext io_context, int op_flags,
                                             const ZTracer::Trace &parent_trace) {
-  ImageCompareAndWriteRequest<I> req(*ictx, c, std::move(image_extents),
+  ImageCompareAndWriteRequest<I> req(*ictx, c, std::move(image_extents), area,
                                      std::move(cmp_bl), std::move(bl),
                                      mismatch_offset, io_context, op_flags,
                                      parent_trace);
@@ -363,12 +366,12 @@ void ImageRequest<I>::update_timestamp() {
 
 template <typename I>
 ImageReadRequest<I>::ImageReadRequest(I &image_ctx, AioCompletion *aio_comp,
-                                      Extents &&image_extents,
+                                      Extents &&image_extents, ImageArea area,
                                       ReadResult &&read_result,
                                       IOContext io_context, int op_flags,
                                      int read_flags,
                                       const ZTracer::Trace &parent_trace)
-  : ImageRequest<I>(image_ctx, aio_comp, std::move(image_extents),
+  : ImageRequest<I>(image_ctx, aio_comp, std::move(image_extents), area,
                     io_context, "read", parent_trace),
     m_op_flags(op_flags), m_read_flags(read_flags) {
   aio_comp->read_result = std::move(read_result);
@@ -380,7 +383,8 @@ void ImageReadRequest<I>::send_request() {
   CephContext *cct = image_ctx.cct;
 
   auto &image_extents = this->m_image_extents;
-  if (image_ctx.cache && image_ctx.readahead_max_bytes > 0 &&
+  if (this->m_image_area == ImageArea::DATA &&
+      image_ctx.cache && image_ctx.readahead_max_bytes > 0 &&
       !(m_op_flags & LIBRADOS_OP_FLAG_FADVISE_RANDOM)) {
     readahead(get_image_ctx(&image_ctx), image_extents, this->m_io_context);
   }
@@ -393,8 +397,9 @@ void ImageReadRequest<I>::send_request() {
       continue;
     }
 
-    util::file_to_extents(&image_ctx, extent.first, extent.second, buffer_ofs,
-                          &object_extents);
+    util::area_to_object_extents(&image_ctx, extent.first, extent.second,
+                                 this->m_image_area, buffer_ofs,
+                                 &object_extents);
     buffer_ofs += extent.second;
   }
 
@@ -444,8 +449,9 @@ void AbstractImageWriteRequest<I>::send_request() {
     }
 
     // map to object extents
-    io::util::file_to_extents(&image_ctx, extent.first, extent.second, clip_len,
-                              &object_extents);
+    io::util::area_to_object_extents(&image_ctx, extent.first, extent.second,
+                                     this->m_image_area, clip_len,
+                                     &object_extents);
     clip_len += extent.second;
   }
 
@@ -814,9 +820,9 @@ int ImageCompareAndWriteRequest<I>::prune_object_extents(
 template <typename I>
 ImageListSnapsRequest<I>::ImageListSnapsRequest(
     I& image_ctx, AioCompletion* aio_comp, Extents&& image_extents,
-    SnapIds&& snap_ids, int list_snaps_flags, SnapshotDelta* snapshot_delta,
-    const ZTracer::Trace& parent_trace)
-  : ImageRequest<I>(image_ctx, aio_comp, std::move(image_extents),
+    ImageArea area, SnapIds&& snap_ids, int list_snaps_flags,
+    SnapshotDelta* snapshot_delta, const ZTracer::Trace& parent_trace)
+  : ImageRequest<I>(image_ctx, aio_comp, std::move(image_extents), area,
                     image_ctx.get_data_io_context(), "list-snaps",
                     parent_trace),
     m_snap_ids(std::move(snap_ids)), m_list_snaps_flags(list_snaps_flags),
@@ -837,8 +843,9 @@ void ImageListSnapsRequest<I>::send_request() {
     }
 
     striper::LightweightObjectExtents object_extents;
-    io::util::file_to_extents(&image_ctx, image_extent.first,
-                              image_extent.second, 0, &object_extents);
+    io::util::area_to_object_extents(&image_ctx, image_extent.first,
+                                     image_extent.second, this->m_image_area, 0,
+                                     &object_extents);
     for (auto& object_extent : object_extents) {
       object_number_extents[object_extent.object_no].emplace_back(
         object_extent.offset, object_extent.length);

diff --git a/src/librbd/io/ImageRequest.h b/src/librbd/io/ImageRequest.h
index 919a7381d378db30b1e72cce77662af34d66dfa8..cd7b203e80cd666b794f2a465b640e1631ea2a39 100644 (file)
--- a/src/librbd/io/ImageRequest.h
+++ b/src/librbd/io/ImageRequest.h
@@ -27,22 +27,21 @@ class ReadResult;
 template <typename ImageCtxT = ImageCtx>
 class ImageRequest {
 public:
-  typedef std::vector<std::pair<uint64_t,uint64_t> > Extents;
-
   virtual ~ImageRequest() {
     m_trace.event("finish");
   }
 
   static void aio_read(ImageCtxT *ictx, AioCompletion *c,
-                       Extents &&image_extents, ReadResult &&read_result,
-                       IOContext io_context, int op_flags, int read_flags,
+                       Extents &&image_extents, ImageArea area,
+                       ReadResult &&read_result, IOContext io_context,
+                       int op_flags, int read_flags,
                        const ZTracer::Trace &parent_trace);
   static void aio_write(ImageCtxT *ictx, AioCompletion *c,
-                        Extents &&image_extents, bufferlist &&bl,
-                        IOContext io_context, int op_flags,
+                        Extents &&image_extents, ImageArea area,
+                        bufferlist &&bl, IOContext io_context, int op_flags,
                        const ZTracer::Trace &parent_trace);
   static void aio_discard(ImageCtxT *ictx, AioCompletion *c,
-                          Extents &&image_extents,
+                          Extents &&image_extents, ImageArea area,
                           uint32_t discard_granularity_bytes,
                           IOContext io_context,
                           const ZTracer::Trace &parent_trace);
@@ -50,12 +49,12 @@ public:
                         FlushSource flush_source,
                         const ZTracer::Trace &parent_trace);
   static void aio_writesame(ImageCtxT *ictx, AioCompletion *c,
-                            Extents &&image_extents, bufferlist &&bl,
-                            IOContext io_context, int op_flags,
+                            Extents &&image_extents, ImageArea area,
+                            bufferlist &&bl, IOContext io_context, int op_flags,
                             const ZTracer::Trace &parent_trace);
 
   static void aio_compare_and_write(ImageCtxT *ictx, AioCompletion *c,
-                                    Extents &&image_extents,
+                                    Extents &&image_extents, ImageArea area,
                                     bufferlist &&cmp_bl,
                                     bufferlist &&bl, uint64_t *mismatch_offset,
                                     IOContext io_context, int op_flags,
@@ -73,15 +72,16 @@ protected:
   ImageCtxT &m_image_ctx;
   AioCompletion *m_aio_comp;
   Extents m_image_extents;
+  ImageArea m_image_area;
   IOContext m_io_context;
   ZTracer::Trace m_trace;
 
   ImageRequest(ImageCtxT &image_ctx, AioCompletion *aio_comp,
-               Extents &&image_extents, IOContext io_context,
-               const char *trace_name,
-              const ZTracer::Trace &parent_trace)
+               Extents &&image_extents, ImageArea area, IOContext io_context,
+               const char *trace_name, const ZTracer::Trace &parent_trace)
     : m_image_ctx(image_ctx), m_aio_comp(aio_comp),
-      m_image_extents(std::move(image_extents)), m_io_context(io_context),
+      m_image_extents(std::move(image_extents)), m_image_area(area),
+      m_io_context(io_context),
       m_trace(librbd::util::create_trace(image_ctx, trace_name, parent_trace)) {
     m_trace.event("start");
   }
@@ -96,12 +96,10 @@ protected:
 template <typename ImageCtxT = ImageCtx>
 class ImageReadRequest : public ImageRequest<ImageCtxT> {
 public:
-  using typename ImageRequest<ImageCtxT>::Extents;
-
   ImageReadRequest(ImageCtxT &image_ctx, AioCompletion *aio_comp,
-                   Extents &&image_extents, ReadResult &&read_result,
-                   IOContext io_context, int op_flags, int read_flags,
-                   const ZTracer::Trace &parent_trace);
+                   Extents &&image_extents, ImageArea area,
+                   ReadResult &&read_result, IOContext io_context, int op_flags,
+                   int read_flags, const ZTracer::Trace &parent_trace);
 
 protected:
   void send_request() override;
@@ -126,14 +124,13 @@ public:
 
 protected:
   using typename ImageRequest<ImageCtxT>::ObjectRequests;
-  using typename ImageRequest<ImageCtxT>::Extents;
 
   AbstractImageWriteRequest(ImageCtxT &image_ctx, AioCompletion *aio_comp,
-                            Extents &&image_extents, IOContext io_context,
-                            const char *trace_name,
+                            Extents &&image_extents, ImageArea area,
+                            IOContext io_context, const char *trace_name,
                            const ZTracer::Trace &parent_trace)
     : ImageRequest<ImageCtxT>(image_ctx, aio_comp, std::move(image_extents),
-                             io_context, trace_name, parent_trace),
+                              area, io_context, trace_name, parent_trace),
       m_synchronous(false) {
   }
 
@@ -160,15 +157,13 @@ private:
 template <typename ImageCtxT = ImageCtx>
 class ImageWriteRequest : public AbstractImageWriteRequest<ImageCtxT> {
 public:
-  using typename ImageRequest<ImageCtxT>::Extents;
-
   ImageWriteRequest(ImageCtxT &image_ctx, AioCompletion *aio_comp,
-                    Extents &&image_extents, bufferlist &&bl,
+                    Extents &&image_extents, ImageArea area, bufferlist &&bl,
                     IOContext io_context, int op_flags,
                    const ZTracer::Trace &parent_trace)
     : AbstractImageWriteRequest<ImageCtxT>(
-       image_ctx, aio_comp, std::move(image_extents), io_context, "write",
-        parent_trace),
+        image_ctx, aio_comp, std::move(image_extents), area, io_context,
+        "write", parent_trace),
       m_bl(std::move(bl)), m_op_flags(op_flags) {
   }
 
@@ -201,12 +196,12 @@ template <typename ImageCtxT = ImageCtx>
 class ImageDiscardRequest : public AbstractImageWriteRequest<ImageCtxT> {
 public:
   ImageDiscardRequest(ImageCtxT &image_ctx, AioCompletion *aio_comp,
-                      Extents&& image_extents,
+                      Extents&& image_extents, ImageArea area,
                      uint32_t discard_granularity_bytes, IOContext io_context,
                       const ZTracer::Trace &parent_trace)
     : AbstractImageWriteRequest<ImageCtxT>(
-       image_ctx, aio_comp, std::move(image_extents), io_context, "discard",
-        parent_trace),
+        image_ctx, aio_comp, std::move(image_extents), area, io_context,
+        "discard", parent_trace),
       m_discard_granularity_bytes(discard_granularity_bytes) {
   }
 
@@ -240,8 +235,9 @@ public:
   ImageFlushRequest(ImageCtxT &image_ctx, AioCompletion *aio_comp,
                     FlushSource flush_source,
                     const ZTracer::Trace &parent_trace)
-    : ImageRequest<ImageCtxT>(image_ctx, aio_comp, {}, {}, "flush",
-                              parent_trace),
+    : ImageRequest<ImageCtxT>(image_ctx, aio_comp, {},
+                              ImageArea::DATA /* dummy for {} */,
+                              {}, "flush", parent_trace),
       m_flush_source(flush_source) {
   }
 
@@ -268,12 +264,12 @@ template <typename ImageCtxT = ImageCtx>
 class ImageWriteSameRequest : public AbstractImageWriteRequest<ImageCtxT> {
 public:
   ImageWriteSameRequest(ImageCtxT &image_ctx, AioCompletion *aio_comp,
-                        Extents&& image_extents, bufferlist &&bl,
-                        IOContext io_context, int op_flags,
+                        Extents&& image_extents, ImageArea area,
+                        bufferlist &&bl, IOContext io_context, int op_flags,
                         const ZTracer::Trace &parent_trace)
     : AbstractImageWriteRequest<ImageCtxT>(
-       image_ctx, aio_comp, std::move(image_extents), io_context, "writesame",
-        parent_trace),
+        image_ctx, aio_comp, std::move(image_extents), area, io_context,
+        "writesame", parent_trace),
       m_data_bl(std::move(bl)), m_op_flags(op_flags) {
   }
 
@@ -304,12 +300,12 @@ public:
   using typename ImageRequest<ImageCtxT>::ObjectRequests;
 
   ImageCompareAndWriteRequest(ImageCtxT &image_ctx, AioCompletion *aio_comp,
-                              Extents &&image_extents, bufferlist &&cmp_bl,
-                              bufferlist &&bl, uint64_t *mismatch_offset,
-                              IOContext io_context, int op_flags,
-                               const ZTracer::Trace &parent_trace)
+                              Extents &&image_extents, ImageArea area,
+                              bufferlist &&cmp_bl, bufferlist &&bl,
+                              uint64_t *mismatch_offset, IOContext io_context,
+                              int op_flags, const ZTracer::Trace &parent_trace)
       : AbstractImageWriteRequest<ImageCtxT>(
-          image_ctx, aio_comp, std::move(image_extents), io_context,
+          image_ctx, aio_comp, std::move(image_extents), area, io_context,
           "compare_and_write", parent_trace),
         m_cmp_bl(std::move(cmp_bl)), m_bl(std::move(bl)),
         m_mismatch_offset(mismatch_offset), m_op_flags(op_flags) {
@@ -346,12 +342,11 @@ private:
 template <typename ImageCtxT = ImageCtx>
 class ImageListSnapsRequest : public ImageRequest<ImageCtxT> {
 public:
-  using typename ImageRequest<ImageCtxT>::Extents;
-
   ImageListSnapsRequest(
       ImageCtxT& image_ctx, AioCompletion* aio_comp,
-      Extents&& image_extents, SnapIds&& snap_ids, int list_snaps_flags,
-      SnapshotDelta* snapshot_delta, const ZTracer::Trace& parent_trace);
+      Extents&& image_extents, ImageArea area, SnapIds&& snap_ids,
+      int list_snaps_flags, SnapshotDelta* snapshot_delta,
+      const ZTracer::Trace& parent_trace);
 
 protected:
   void update_timestamp() override {}

diff --git a/src/librbd/io/ObjectRequest.cc b/src/librbd/io/ObjectRequest.cc
index 0ce90e30de3bdf3cf0a71447717dc303de60eed8..9c27be813524c29e6ac9d09a5facc5ceb999a456 100644 (file)
--- a/src/librbd/io/ObjectRequest.cc
+++ b/src/librbd/io/ObjectRequest.cc
@@ -992,7 +992,7 @@ void ObjectListSnapsRequest<I>::list_from_parent() {
      m_list_snaps_flags | LIST_SNAPS_FLAG_IGNORE_ZEROED_EXTENTS);
 
   ImageListSnapsRequest<I> req(
-    *image_ctx->parent, aio_comp, std::move(parent_extents),
+    *image_ctx->parent, aio_comp, std::move(parent_extents), m_image_area,
     {0, image_ctx->parent->snap_id}, list_snaps_flags, &m_parent_snapshot_delta,
     this->m_trace);
   req.send();
@@ -1023,8 +1023,9 @@ void ObjectListSnapsRequest<I>::handle_list_from_parent(int r) {
 
       // map image-extents back to this object
       striper::LightweightObjectExtents object_extents;
-      io::util::file_to_extents(image_ctx, image_extent.get_off(),
-                                image_extent.get_len(), 0, &object_extents);
+      io::util::area_to_object_extents(image_ctx, image_extent.get_off(),
+                                       image_extent.get_len(), m_image_area, 0,
+                                       &object_extents);
       for (auto& object_extent : object_extents) {
         ceph_assert(object_extent.object_no == this->m_object_no);
         intervals.insert(

diff --git a/src/librbd/io/Types.h b/src/librbd/io/Types.h
index 8ca9ccb1b4332777c72d7f3fa592533441e8fc08..7c70986c5846aada3c65dbe19a3c70fc8bea8fb1 100644 (file)
--- a/src/librbd/io/Types.h
+++ b/src/librbd/io/Types.h
@@ -95,6 +95,10 @@ enum {
   IMAGE_DISPATCH_FLAG_QOS_MASK                = (
     IMAGE_DISPATCH_FLAG_QOS_BPS_MASK |
     IMAGE_DISPATCH_FLAG_QOS_IOPS_MASK),
+
+  // TODO: pass area through ImageDispatchInterface and remove
+  // this flag
+  IMAGE_DISPATCH_FLAG_CRYPTO_HEADER           = 1 << 6
 };
 
 enum {

diff --git a/src/librbd/io/Utils.cc b/src/librbd/io/Utils.cc
index c5fa3484e237feaf3a847a4f7c908366675a1386..f4cb42957e7aaa2ec544225859596cecb0cf30ac 100644 (file)
--- a/src/librbd/io/Utils.cc
+++ b/src/librbd/io/Utils.cc
@@ -184,12 +184,11 @@ bool trigger_copyup(I* image_ctx, uint64_t object_no, IOContext io_context,
 }
 
 template <typename I>
-void file_to_extents(I* image_ctx, uint64_t offset, uint64_t length,
-                     uint64_t buffer_offset,
-                     striper::LightweightObjectExtents* object_extents) {
+void area_to_object_extents(I* image_ctx, uint64_t offset, uint64_t length,
+                            ImageArea area, uint64_t buffer_offset,
+                            striper::LightweightObjectExtents* object_extents) {
   Extents extents = {{offset, length}};
-  // TODO: pass area
-  image_ctx->io_image_dispatcher->remap_to_physical(extents, ImageArea::DATA);
+  image_ctx->io_image_dispatcher->remap_to_physical(extents, area);
   for (auto [off, len] : extents) {
     Striper::file_to_extents(image_ctx->cct, &image_ctx->layout, off, len, 0,
                              buffer_offset, object_extents);
@@ -245,10 +244,10 @@ template int librbd::io::util::clip_request(
 template bool librbd::io::util::trigger_copyup(
         librbd::ImageCtx *image_ctx, uint64_t object_no, IOContext io_context,
         Context* on_finish);
-template void librbd::io::util::file_to_extents(
-        librbd::ImageCtx *image_ctx, uint64_t offset, uint64_t length,
-        uint64_t buffer_offset,
-        striper::LightweightObjectExtents* object_extents);
+template void librbd::io::util::area_to_object_extents(
+    librbd::ImageCtx* image_ctx, uint64_t offset, uint64_t length,
+    ImageArea area, uint64_t buffer_offset,
+    striper::LightweightObjectExtents* object_extents);
 template auto librbd::io::util::object_to_area_extents(
     librbd::ImageCtx* image_ctx, uint64_t object_no, const Extents& extents)
     -> std::pair<Extents, ImageArea>;

diff --git a/src/librbd/io/Utils.h b/src/librbd/io/Utils.h
index 16a14c105331aad5e2ea87de9a273ac91711ee1a..f2096de842d707a331014ce3232bdda3c7aa61bf 100644 (file)
--- a/src/librbd/io/Utils.h
+++ b/src/librbd/io/Utils.h
@@ -53,11 +53,12 @@ void unsparsify(CephContext* cct, ceph::bufferlist* bl,
 template <typename ImageCtxT = librbd::ImageCtx>
 bool trigger_copyup(ImageCtxT *image_ctx, uint64_t object_no,
                     IOContext io_context, Context* on_finish);
-                
+
 template <typename ImageCtxT = librbd::ImageCtx>
-void file_to_extents(ImageCtxT *image_ctx, uint64_t offset, uint64_t length,
-                     uint64_t buffer_offset,
-                     striper::LightweightObjectExtents* object_extents);
+void area_to_object_extents(ImageCtxT* image_ctx, uint64_t offset,
+                            uint64_t length, ImageArea area,
+                            uint64_t buffer_offset,
+                            striper::LightweightObjectExtents* object_extents);
 
 template <typename ImageCtxT = librbd::ImageCtx>
 std::pair<Extents, ImageArea> object_to_area_extents(

diff --git a/src/librbd/journal/Replay.cc b/src/librbd/journal/Replay.cc
index db73edb610947e6f77258a5ccdeeacb65892ed23..c35b44bfcd727002729c89faa5b38c19484fe796 100644 (file)
--- a/src/librbd/journal/Replay.cc
+++ b/src/librbd/journal/Replay.cc
@@ -356,6 +356,7 @@ void Replay<I>::handle_event(const journal::AioDiscardEvent &event,
   if (!clipped_io(event.offset, aio_comp)) {
     io::ImageRequest<I>::aio_discard(&m_image_ctx, aio_comp,
                                      {{event.offset, event.length}},
+                                     io::ImageArea::DATA,
                                      event.discard_granularity_bytes,
                                      m_image_ctx.get_data_io_context(), {});
   }
@@ -391,7 +392,7 @@ void Replay<I>::handle_event(const journal::AioWriteEvent &event,
   if (!clipped_io(event.offset, aio_comp)) {
     io::ImageRequest<I>::aio_write(&m_image_ctx, aio_comp,
                                    {{event.offset, event.length}},
-                                   std::move(data),
+                                   io::ImageArea::DATA, std::move(data),
                                    m_image_ctx.get_data_io_context(), 0, {});
   }
 
@@ -445,7 +446,7 @@ void Replay<I>::handle_event(const journal::AioWriteSameEvent &event,
   if (!clipped_io(event.offset, aio_comp)) {
     io::ImageRequest<I>::aio_writesame(&m_image_ctx, aio_comp,
                                        {{event.offset, event.length}},
-                                       std::move(data),
+                                       io::ImageArea::DATA, std::move(data),
                                        m_image_ctx.get_data_io_context(), 0,
                                        {});
   }
@@ -479,6 +480,7 @@ void Replay<I>::handle_event(const journal::AioWriteSameEvent &event,
   if (!clipped_io(event.offset, aio_comp)) {
     io::ImageRequest<I>::aio_compare_and_write(&m_image_ctx, aio_comp,
                                                {{event.offset, event.length}},
+                                               io::ImageArea::DATA,
                                                std::move(cmp_data),
                                                std::move(write_data),
                                                nullptr,

diff --git a/src/test/librbd/deep_copy/test_mock_ObjectCopyRequest.cc b/src/test/librbd/deep_copy/test_mock_ObjectCopyRequest.cc
index af0ebd28cced47379a312d862a5766f80973b999..d813a5a33bcfd89409d9da740ea91a0714f8718b 100644 (file)
--- a/src/test/librbd/deep_copy/test_mock_ObjectCopyRequest.cc
+++ b/src/test/librbd/deep_copy/test_mock_ObjectCopyRequest.cc
@@ -45,10 +45,11 @@ inline ImageCtx* get_image_ctx(MockTestImageCtx* image_ctx) {
 namespace io {
 namespace util {
 
-template <> void file_to_extents(
-        MockTestImageCtx* image_ctx, uint64_t offset, uint64_t length,
-        uint64_t buffer_offset,
-        striper::LightweightObjectExtents* object_extents) {
+template <>
+void area_to_object_extents(MockTestImageCtx* image_ctx, uint64_t offset,
+                            uint64_t length, ImageArea area,
+                            uint64_t buffer_offset,
+                            striper::LightweightObjectExtents* object_extents) {
   Striper::file_to_extents(image_ctx->cct, &image_ctx->layout, offset, length,
                            0, buffer_offset, object_extents);
 }

diff --git a/src/test/librbd/io/test_mock_CopyupRequest.cc b/src/test/librbd/io/test_mock_CopyupRequest.cc
index f7f2611490cfe61268be97533a064b82e48f3f42..b8a193619deacdcdfc1dd31e7612ed3c9582061a 100644 (file)
--- a/src/test/librbd/io/test_mock_CopyupRequest.cc
+++ b/src/test/librbd/io/test_mock_CopyupRequest.cc
@@ -84,10 +84,11 @@ namespace io {
 
 namespace util {
 
-template <> void file_to_extents(
-        MockTestImageCtx* image_ctx, uint64_t offset, uint64_t length,
-        uint64_t buffer_offset,
-        striper::LightweightObjectExtents* object_extents) {
+template <>
+void area_to_object_extents(MockTestImageCtx* image_ctx, uint64_t offset,
+                            uint64_t length, ImageArea area,
+                            uint64_t buffer_offset,
+                            striper::LightweightObjectExtents* object_extents) {
   Striper::file_to_extents(image_ctx->cct, &image_ctx->layout, offset, length,
                            0, buffer_offset, object_extents);
 }

diff --git a/src/test/librbd/io/test_mock_ImageRequest.cc b/src/test/librbd/io/test_mock_ImageRequest.cc
index 8487c4d5537a7727a0a62485d9ff0687fe7e94d5..e2ac825630ccce4dd750ee26c1873f2833a1022e 100644 (file)
--- a/src/test/librbd/io/test_mock_ImageRequest.cc
+++ b/src/test/librbd/io/test_mock_ImageRequest.cc
@@ -60,11 +60,11 @@ namespace io {
 
 namespace util {
 
-template<>
-void file_to_extents(
-        MockTestImageCtx *image_ctx, uint64_t offset, uint64_t length,
-        uint64_t buffer_offset,
-        striper::LightweightObjectExtents *object_extents) {
+template <>
+void area_to_object_extents(MockTestImageCtx* image_ctx, uint64_t offset,
+                            uint64_t length, ImageArea area,
+                            uint64_t buffer_offset,
+                            striper::LightweightObjectExtents* object_extents) {
   Striper::file_to_extents(image_ctx->cct, &image_ctx->layout, offset, length,
                            0, buffer_offset, object_extents);
 }
@@ -204,7 +204,7 @@ TEST_F(TestMockIoImageRequest, AioWriteModifyTimestamp) {
   bufferlist bl;
   bl.append("1");
   MockImageWriteRequest mock_aio_image_write_1(
-    mock_image_ctx, aio_comp_1, {{0, 1}}, std::move(bl),
+    mock_image_ctx, aio_comp_1, {{0, 1}}, ImageArea::DATA, std::move(bl),
     mock_image_ctx.get_data_io_context(), 0, {});
   {
     std::shared_lock owner_locker{mock_image_ctx.owner_lock};
@@ -217,7 +217,7 @@ TEST_F(TestMockIoImageRequest, AioWriteModifyTimestamp) {
 
   bl.append("1");
   MockImageWriteRequest mock_aio_image_write_2(
-    mock_image_ctx, aio_comp_2, {{0, 1}}, std::move(bl),
+    mock_image_ctx, aio_comp_2, {{0, 1}}, ImageArea::DATA, std::move(bl),
     mock_image_ctx.get_data_io_context(), 0, {});
   {
     std::shared_lock owner_locker{mock_image_ctx.owner_lock};
@@ -260,7 +260,7 @@ TEST_F(TestMockIoImageRequest, AioReadAccessTimestamp) {
 
   ReadResult rr;
   MockImageReadRequest mock_aio_image_read_1(
-    mock_image_ctx, aio_comp_1, {{0, 1}}, std::move(rr),
+    mock_image_ctx, aio_comp_1, {{0, 1}}, ImageArea::DATA, std::move(rr),
     mock_image_ctx.get_data_io_context(), 0, 0, {});
   {
     std::shared_lock owner_locker{mock_image_ctx.owner_lock};
@@ -273,7 +273,7 @@ TEST_F(TestMockIoImageRequest, AioReadAccessTimestamp) {
   expect_object_request_send(mock_image_ctx, 0);
 
   MockImageReadRequest mock_aio_image_read_2(
-    mock_image_ctx, aio_comp_2, {{0, 1}}, std::move(rr),
+    mock_image_ctx, aio_comp_2, {{0, 1}}, ImageArea::DATA, std::move(rr),
     mock_image_ctx.get_data_io_context(), 0, 0, {});
   {
     std::shared_lock owner_locker{mock_image_ctx.owner_lock};
@@ -299,7 +299,7 @@ TEST_F(TestMockIoImageRequest, PartialDiscard) {
   AioCompletion *aio_comp = AioCompletion::create_and_start(
     &aio_comp_ctx, ictx, AIO_TYPE_DISCARD);
   MockImageDiscardRequest mock_aio_image_discard(
-    mock_image_ctx, aio_comp, {{16, 63}, {84, 100}},
+    mock_image_ctx, aio_comp, {{16, 63}, {84, 100}}, ImageArea::DATA,
     ictx->discard_granularity_bytes, mock_image_ctx.get_data_io_context(), {});
   {
     std::shared_lock owner_locker{mock_image_ctx.owner_lock};
@@ -327,7 +327,7 @@ TEST_F(TestMockIoImageRequest, TailDiscard) {
     &aio_comp_ctx, ictx, AIO_TYPE_DISCARD);
   MockImageDiscardRequest mock_aio_image_discard(
     mock_image_ctx, aio_comp,
-    {{ictx->layout.object_size - 1024, 1024}},
+    {{ictx->layout.object_size - 1024, 1024}}, ImageArea::DATA,
     ictx->discard_granularity_bytes, mock_image_ctx.get_data_io_context(), {});
   {
     std::shared_lock owner_locker{mock_image_ctx.owner_lock};
@@ -358,7 +358,8 @@ TEST_F(TestMockIoImageRequest, DiscardGranularity) {
   MockImageDiscardRequest mock_aio_image_discard(
     mock_image_ctx, aio_comp,
     {{16, 63}, {96, 31}, {84, 100}, {ictx->layout.object_size - 33, 33}},
-    ictx->discard_granularity_bytes, mock_image_ctx.get_data_io_context(), {});
+    ImageArea::DATA, ictx->discard_granularity_bytes,
+    mock_image_ctx.get_data_io_context(), {});
   {
     std::shared_lock owner_locker{mock_image_ctx.owner_lock};
     mock_aio_image_discard.send();
@@ -388,7 +389,7 @@ TEST_F(TestMockIoImageRequest, AioWriteJournalAppendDisabled) {
   bufferlist bl;
   bl.append("1");
   MockImageWriteRequest mock_aio_image_write(
-    mock_image_ctx, aio_comp, {{0, 1}}, std::move(bl),
+    mock_image_ctx, aio_comp, {{0, 1}}, ImageArea::DATA, std::move(bl),
     mock_image_ctx.get_data_io_context(), 0, {});
   {
     std::shared_lock owner_locker{mock_image_ctx.owner_lock};
@@ -417,8 +418,8 @@ TEST_F(TestMockIoImageRequest, AioDiscardJournalAppendDisabled) {
   AioCompletion *aio_comp = AioCompletion::create_and_start(
     &aio_comp_ctx, ictx, AIO_TYPE_DISCARD);
   MockImageDiscardRequest mock_aio_image_discard(
-    mock_image_ctx, aio_comp, {{0, 1}}, ictx->discard_granularity_bytes,
-    mock_image_ctx.get_data_io_context(), {});
+    mock_image_ctx, aio_comp, {{0, 1}}, ImageArea::DATA,
+    ictx->discard_granularity_bytes, mock_image_ctx.get_data_io_context(), {});
   {
     std::shared_lock owner_locker{mock_image_ctx.owner_lock};
     mock_aio_image_discard.send();
@@ -476,7 +477,7 @@ TEST_F(TestMockIoImageRequest, AioWriteSameJournalAppendDisabled) {
   bufferlist bl;
   bl.append("1");
   MockImageWriteSameRequest mock_aio_image_writesame(
-    mock_image_ctx, aio_comp, {{0, 1}}, std::move(bl),
+    mock_image_ctx, aio_comp, {{0, 1}}, ImageArea::DATA, std::move(bl),
     mock_image_ctx.get_data_io_context(), 0, {});
   {
     std::shared_lock owner_locker{mock_image_ctx.owner_lock};
@@ -510,8 +511,9 @@ TEST_F(TestMockIoImageRequest, AioCompareAndWriteJournalAppendDisabled) {
   write_bl.append("1");
   uint64_t mismatch_offset;
   MockImageCompareAndWriteRequest mock_aio_image_write(
-    mock_image_ctx, aio_comp, {{0, 1}}, std::move(cmp_bl), std::move(write_bl),
-    &mismatch_offset, mock_image_ctx.get_data_io_context(), 0, {});
+    mock_image_ctx, aio_comp, {{0, 1}}, ImageArea::DATA,
+    std::move(cmp_bl), std::move(write_bl), &mismatch_offset,
+    mock_image_ctx.get_data_io_context(), 0, {});
   {
     std::shared_lock owner_locker{mock_image_ctx.owner_lock};
     mock_aio_image_write.send();
@@ -548,8 +550,8 @@ TEST_F(TestMockIoImageRequest, ListSnaps) {
   AioCompletion *aio_comp = AioCompletion::create_and_start(
     &aio_comp_ctx, ictx, AIO_TYPE_GENERIC);
   MockImageListSnapsRequest mock_image_list_snaps_request(
-    mock_image_ctx, aio_comp, {{0, 16384}, {16384, 16384}}, {0, CEPH_NOSNAP},
-    0, &snapshot_delta, {});
+    mock_image_ctx, aio_comp, {{0, 16384}, {16384, 16384}}, ImageArea::DATA,
+    {0, CEPH_NOSNAP}, 0, &snapshot_delta, {});
   {
     std::shared_lock owner_locker{mock_image_ctx.owner_lock};
     mock_image_list_snaps_request.send();

diff --git a/src/test/librbd/io/test_mock_ObjectRequest.cc b/src/test/librbd/io/test_mock_ObjectRequest.cc
index 38ac506c4f85271d5c9012304acce0532e485bec..503c83827d5a2e4d53e489e7d2c8c7fc3f05161f 100644 (file)
--- a/src/test/librbd/io/test_mock_ObjectRequest.cc
+++ b/src/test/librbd/io/test_mock_ObjectRequest.cc
@@ -71,8 +71,9 @@ struct ImageListSnapsRequest<librbd::MockTestImageCtx> {
   }
   ImageListSnapsRequest(
       librbd::MockImageCtx& image_ctx, AioCompletion* aio_comp,
-      Extents&& image_extents, SnapIds&& snap_ids, int list_snaps_flags,
-      SnapshotDelta* snapshot_delta, const ZTracer::Trace& parent_trace) {
+      Extents&& image_extents, ImageArea area, SnapIds&& snap_ids,
+      int list_snaps_flags, SnapshotDelta* snapshot_delta,
+      const ZTracer::Trace& parent_trace) {
     ceph_assert(s_instance != nullptr);
     s_instance->aio_comp = aio_comp;
     s_instance->image_extents = image_extents;
@@ -91,10 +92,11 @@ ImageListSnapsRequest<librbd::MockTestImageCtx>* ImageListSnapsRequest<librbd::M
 
 namespace util {
 
-template <> void file_to_extents(
-        MockTestImageCtx* image_ctx, uint64_t offset, uint64_t length,
-        uint64_t buffer_offset,
-        striper::LightweightObjectExtents* object_extents) {
+template <>
+void area_to_object_extents(MockTestImageCtx* image_ctx, uint64_t offset,
+                            uint64_t length, ImageArea area,
+                            uint64_t buffer_offset,
+                            striper::LightweightObjectExtents* object_extents) {
   Striper::file_to_extents(image_ctx->cct, &image_ctx->layout, offset, length,
                            0, buffer_offset, object_extents);
 }

diff --git a/src/test/librbd/journal/test_mock_Replay.cc b/src/test/librbd/journal/test_mock_Replay.cc
index b902e0f95924570ad03b1ef725837c673ac68d52..7bed2532aa87d327d11d3f6a81ef3186b1205c68 100644 (file)
--- a/src/test/librbd/journal/test_mock_Replay.cc
+++ b/src/test/librbd/journal/test_mock_Replay.cc
@@ -31,8 +31,8 @@ struct ImageRequest<MockReplayImageCtx> {
   MOCK_METHOD4(aio_write, void(AioCompletion *c, const Extents &image_extents,
                                const bufferlist &bl, int op_flags));
   static void aio_write(MockReplayImageCtx *ictx, AioCompletion *c,
-                        Extents &&image_extents, bufferlist &&bl,
-                        IOContext io_context, int op_flags,
+                        Extents&& image_extents, ImageArea area,
+                        bufferlist&& bl, IOContext io_context, int op_flags,
                         const ZTracer::Trace &parent_trace) {
     ceph_assert(s_instance != nullptr);
     s_instance->aio_write(c, image_extents, bl, op_flags);
@@ -41,7 +41,7 @@ struct ImageRequest<MockReplayImageCtx> {
   MOCK_METHOD3(aio_discard, void(AioCompletion *c, const Extents& image_extents,
                                  uint32_t discard_granularity_bytes));
   static void aio_discard(MockReplayImageCtx *ictx, AioCompletion *c,
-                          Extents&& image_extents,
+                          Extents&& image_extents, ImageArea area,
                           uint32_t discard_granularity_bytes,
                           IOContext io_context,
                           const ZTracer::Trace &parent_trace) {
@@ -61,8 +61,8 @@ struct ImageRequest<MockReplayImageCtx> {
                                    const bufferlist &bl,
                                    int op_flags));
   static void aio_writesame(MockReplayImageCtx *ictx, AioCompletion *c,
-                            Extents&& image_extents, bufferlist &&bl,
-                            IOContext io_context, int op_flags,
+                            Extents&& image_extents, ImageArea area,
+                            bufferlist&& bl, IOContext io_context, int op_flags,
                             const ZTracer::Trace &parent_trace) {
     ceph_assert(s_instance != nullptr);
     s_instance->aio_writesame(c, image_extents, bl, op_flags);
@@ -73,8 +73,9 @@ struct ImageRequest<MockReplayImageCtx> {
                                            uint64_t *mismatch_offset,
                                            int op_flags));
   static void aio_compare_and_write(MockReplayImageCtx *ictx, AioCompletion *c,
-                                    Extents &&image_extents, bufferlist &&cmp_bl,
-                                    bufferlist &&bl, uint64_t *mismatch_offset,
+                                    Extents&& image_extents, ImageArea area,
+                                    bufferlist&& cmp_bl, bufferlist&& bl,
+                                    uint64_t* mismatch_offset,
                                     IOContext io_context, int op_flags,
                                     const ZTracer::Trace &parent_trace) {
     ceph_assert(s_instance != nullptr);