librbd: pass area to ImageDispatchSpec::create_*()

- DATA area is assumed at the API layer as there is no way to pass
  an area
- DATA area is assumed by ImageWriteback because PWL cache persists
  image extents as provided by the user without any kind of designator
  and therefore can be active only in either area
- luks::FlattenRequest operates on CRYPTO_HEADER area

The passed area is acted upon in ImageDispatchSpec constructor in the
next commit.

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

diff --git a/src/librbd/api/DiffIterate.cc b/src/librbd/api/DiffIterate.cc
index fa1df6df373403868b98d41f3d961e61292035c9..489763cf6def2b207fefec2dac2b4f83d015b826 100644 (file)
--- a/src/librbd/api/DiffIterate.cc
+++ b/src/librbd/api/DiffIterate.cc
@@ -73,7 +73,7 @@ public:
     }
     auto req = io::ImageDispatchSpec::create_list_snaps(
       m_image_ctx, io::IMAGE_DISPATCH_LAYER_INTERNAL_START,
-      aio_comp, {{m_image_offset, m_image_length}},
+      aio_comp, {{m_image_offset, m_image_length}}, io::ImageArea::DATA,
       {m_diff_context.from_snap_id, m_diff_context.end_snap_id},
       list_snaps_flags, &m_snapshot_delta, {});
     req->send();

diff --git a/src/librbd/api/Io.cc b/src/librbd/api/Io.cc
index c83cdfb49c9274550f919f8daae0301647ae52d4..fb8501bde91c55c6881d5b45006ff1691c264dc9 100644 (file)
--- a/src/librbd/api/Io.cc
+++ b/src/librbd/api/Io.cc
@@ -231,9 +231,9 @@ void Io<I>::aio_read(I &image_ctx, io::AioCompletion *aio_comp, uint64_t off,
   }
 
   auto req = io::ImageDispatchSpec::create_read(
-    image_ctx, io::IMAGE_DISPATCH_LAYER_API_START, aio_comp, {{off, len}},
-    std::move(read_result), image_ctx.get_data_io_context(), op_flags, 0,
-    trace);
+      image_ctx, io::IMAGE_DISPATCH_LAYER_API_START, aio_comp,
+      {{off, len}}, io::ImageArea::DATA, std::move(read_result),
+      image_ctx.get_data_io_context(), op_flags, 0, trace);
   req->send();
 }
 
@@ -263,8 +263,9 @@ void Io<I>::aio_write(I &image_ctx, io::AioCompletion *aio_comp, uint64_t off,
   }
 
   auto req = io::ImageDispatchSpec::create_write(
-    image_ctx, io::IMAGE_DISPATCH_LAYER_API_START, aio_comp, {{off, len}},
-    std::move(bl), image_ctx.get_data_io_context(), op_flags, trace);
+      image_ctx, io::IMAGE_DISPATCH_LAYER_API_START, aio_comp,
+      {{off, len}}, io::ImageArea::DATA, std::move(bl),
+      image_ctx.get_data_io_context(), op_flags, trace);
   req->send();
 }
 
@@ -294,8 +295,9 @@ void Io<I>::aio_discard(I &image_ctx, io::AioCompletion *aio_comp, uint64_t off,
   }
 
   auto req = io::ImageDispatchSpec::create_discard(
-    image_ctx, io::IMAGE_DISPATCH_LAYER_API_START, aio_comp, {{off, len}},
-    discard_granularity_bytes, image_ctx.get_data_io_context(), trace);
+      image_ctx, io::IMAGE_DISPATCH_LAYER_API_START, aio_comp,
+      {{off, len}}, io::ImageArea::DATA, discard_granularity_bytes,
+      image_ctx.get_data_io_context(), trace);
   req->send();
 }
 
@@ -326,8 +328,9 @@ void Io<I>::aio_write_same(I &image_ctx, io::AioCompletion *aio_comp,
   }
 
   auto req = io::ImageDispatchSpec::create_write_same(
-    image_ctx, io::IMAGE_DISPATCH_LAYER_API_START, aio_comp, {{off, len}},
-    std::move(bl), image_ctx.get_data_io_context(), op_flags, trace);
+      image_ctx, io::IMAGE_DISPATCH_LAYER_API_START, aio_comp,
+      {{off, len}}, io::ImageArea::DATA, std::move(bl),
+      image_ctx.get_data_io_context(), op_flags, trace);
   req->send();
 }
 
@@ -399,8 +402,9 @@ void Io<I>::aio_write_zeroes(I& image_ctx, io::AioCompletion *aio_comp,
 
       aio_comp->aio_type = io::AIO_TYPE_WRITE;
       auto req = io::ImageDispatchSpec::create_write(
-        image_ctx, io::IMAGE_DISPATCH_LAYER_API_START, aio_comp, {{off, len}},
-        std::move(bl), image_ctx.get_data_io_context(), op_flags, trace);
+          image_ctx, io::IMAGE_DISPATCH_LAYER_API_START, aio_comp,
+          {{off, len}}, io::ImageArea::DATA, std::move(bl),
+          image_ctx.get_data_io_context(), op_flags, trace);
       req->send();
       return;
     } else if (prepend_length == 0 && append_length == 0) {
@@ -409,8 +413,9 @@ void Io<I>::aio_write_zeroes(I& image_ctx, io::AioCompletion *aio_comp,
       bl.append_zero(data_length);
 
       auto req = io::ImageDispatchSpec::create_write_same(
-        image_ctx, io::IMAGE_DISPATCH_LAYER_API_START, aio_comp, {{off, len}},
-        std::move(bl), image_ctx.get_data_io_context(), op_flags, trace);
+          image_ctx, io::IMAGE_DISPATCH_LAYER_API_START, aio_comp,
+          {{off, len}}, io::ImageArea::DATA, std::move(bl),
+          image_ctx.get_data_io_context(), op_flags, trace);
       req->send();
       return;
     }
@@ -437,9 +442,9 @@ void Io<I>::aio_write_zeroes(I& image_ctx, io::AioCompletion *aio_comp,
       auto prepend_aio_comp = io::AioCompletion::create_and_start(
         prepend_ctx, &image_ctx, io::AIO_TYPE_WRITE);
       auto prepend_req = io::ImageDispatchSpec::create_write(
-        image_ctx, io::IMAGE_DISPATCH_LAYER_API_START, prepend_aio_comp,
-        {{prepend_offset, prepend_length}}, std::move(bl),
-        image_ctx.get_data_io_context(), op_flags, trace);
+          image_ctx, io::IMAGE_DISPATCH_LAYER_API_START, prepend_aio_comp,
+          {{prepend_offset, prepend_length}}, io::ImageArea::DATA,
+          std::move(bl), image_ctx.get_data_io_context(), op_flags, trace);
       prepend_req->send();
     }
 
@@ -451,9 +456,9 @@ void Io<I>::aio_write_zeroes(I& image_ctx, io::AioCompletion *aio_comp,
       auto append_aio_comp = io::AioCompletion::create_and_start(
         append_ctx, &image_ctx, io::AIO_TYPE_WRITE);
       auto append_req = io::ImageDispatchSpec::create_write(
-        image_ctx, io::IMAGE_DISPATCH_LAYER_API_START, append_aio_comp,
-        {{append_offset, append_length}}, std::move(bl),
-        image_ctx.get_data_io_context(), op_flags, trace);
+          image_ctx, io::IMAGE_DISPATCH_LAYER_API_START, append_aio_comp,
+          {{append_offset, append_length}}, io::ImageArea::DATA,
+          std::move(bl), image_ctx.get_data_io_context(), op_flags, trace);
       append_req->send();
     }
 
@@ -464,9 +469,9 @@ void Io<I>::aio_write_zeroes(I& image_ctx, io::AioCompletion *aio_comp,
     auto write_same_aio_comp = io::AioCompletion::create_and_start(
       write_same_ctx, &image_ctx, io::AIO_TYPE_WRITESAME);
     auto req = io::ImageDispatchSpec::create_write_same(
-      image_ctx, io::IMAGE_DISPATCH_LAYER_API_START, write_same_aio_comp,
-      {{write_same_offset, write_same_length}}, std::move(bl),
-      image_ctx.get_data_io_context(), op_flags, trace);
+        image_ctx, io::IMAGE_DISPATCH_LAYER_API_START, write_same_aio_comp,
+        {{write_same_offset, write_same_length}}, io::ImageArea::DATA,
+        std::move(bl), image_ctx.get_data_io_context(), op_flags, trace);
     req->send();
     return;
   }
@@ -475,8 +480,9 @@ void Io<I>::aio_write_zeroes(I& image_ctx, io::AioCompletion *aio_comp,
   uint32_t discard_granularity_bytes = 0;
 
   auto req = io::ImageDispatchSpec::create_discard(
-    image_ctx, io::IMAGE_DISPATCH_LAYER_API_START, aio_comp, {{off, len}},
-    discard_granularity_bytes, image_ctx.get_data_io_context(), trace);
+      image_ctx, io::IMAGE_DISPATCH_LAYER_API_START, aio_comp,
+      {{off, len}}, io::ImageArea::DATA, discard_granularity_bytes,
+      image_ctx.get_data_io_context(), trace);
   req->send();
 }
 
@@ -509,9 +515,9 @@ void Io<I>::aio_compare_and_write(I &image_ctx, io::AioCompletion *aio_comp,
   }
 
   auto req = io::ImageDispatchSpec::create_compare_and_write(
-    image_ctx, io::IMAGE_DISPATCH_LAYER_API_START, aio_comp, {{off, len}},
-    std::move(cmp_bl), std::move(bl), mismatch_off,
-    image_ctx.get_data_io_context(), op_flags, trace);
+      image_ctx, io::IMAGE_DISPATCH_LAYER_API_START, aio_comp,
+      {{off, len}}, io::ImageArea::DATA, std::move(cmp_bl), std::move(bl),
+      mismatch_off, image_ctx.get_data_io_context(), op_flags, trace);
   req->send();
 }
 

diff --git a/src/librbd/cache/ImageWriteback.cc b/src/librbd/cache/ImageWriteback.cc
index 88de61cda59858505b5317b1ef7ca9901036a6d0..1145a8c9dc4a33653951accaa5229ab03f1e18fa 100644 (file)
--- a/src/librbd/cache/ImageWriteback.cc
+++ b/src/librbd/cache/ImageWriteback.cc
@@ -36,9 +36,8 @@ void ImageWriteback<I>::aio_read(Extents &&image_extents, bufferlist *bl,
   ZTracer::Trace trace;
   auto req = io::ImageDispatchSpec::create_read(
     *image_ctx, io::IMAGE_DISPATCH_LAYER_WRITEBACK_CACHE, aio_comp,
-    std::move(image_extents), io::ReadResult{bl},
-    image_ctx->get_data_io_context(),
-    fadvise_flags, 0, trace);
+    std::move(image_extents), io::ImageArea::DATA, io::ReadResult{bl},
+    image_ctx->get_data_io_context(), fadvise_flags, 0, trace);
   req->send();
 }
 
@@ -56,7 +55,7 @@ void ImageWriteback<I>::aio_write(Extents &&image_extents,
   ZTracer::Trace trace;
   auto req = io::ImageDispatchSpec::create_write(
     *image_ctx, io::IMAGE_DISPATCH_LAYER_WRITEBACK_CACHE, aio_comp,
-    std::move(image_extents), std::move(bl),
+    std::move(image_extents), io::ImageArea::DATA, std::move(bl),
     image_ctx->get_data_io_context(), fadvise_flags, trace);
   req->send();
 }
@@ -76,7 +75,7 @@ void ImageWriteback<I>::aio_discard(uint64_t offset, uint64_t length,
   ZTracer::Trace trace;
   auto req = io::ImageDispatchSpec::create_discard(
     *image_ctx, io::IMAGE_DISPATCH_LAYER_WRITEBACK_CACHE, aio_comp,
-    {{offset, length}}, discard_granularity_bytes,
+    {{offset, length}}, io::ImageArea::DATA, discard_granularity_bytes,
     image_ctx->get_data_io_context(), trace);
   req->send();
 }
@@ -114,8 +113,8 @@ void ImageWriteback<I>::aio_writesame(uint64_t offset, uint64_t length,
   ZTracer::Trace trace;
   auto req = io::ImageDispatchSpec::create_write_same(
     *image_ctx, io::IMAGE_DISPATCH_LAYER_WRITEBACK_CACHE, aio_comp,
-    {{offset, length}}, std::move(bl), image_ctx->get_data_io_context(),
-    fadvise_flags, trace);
+    {{offset, length}}, io::ImageArea::DATA, std::move(bl),
+    image_ctx->get_data_io_context(), fadvise_flags, trace);
   req->send();
 }
 
@@ -136,8 +135,8 @@ void ImageWriteback<I>::aio_compare_and_write(Extents &&image_extents,
   ZTracer::Trace trace;
   auto req = io::ImageDispatchSpec::create_compare_and_write(
     *image_ctx, io::IMAGE_DISPATCH_LAYER_WRITEBACK_CACHE, aio_comp,
-    std::move(image_extents), std::move(cmp_bl), std::move(bl),
-    mismatch_offset, image_ctx->get_data_io_context(),
+    std::move(image_extents), io::ImageArea::DATA, std::move(cmp_bl),
+    std::move(bl), mismatch_offset, image_ctx->get_data_io_context(),
     fadvise_flags, trace);
   req->send();
 }

diff --git a/src/librbd/crypto/luks/FlattenRequest.cc b/src/librbd/crypto/luks/FlattenRequest.cc
index 89ad3d4a5399ad545ed71c211508384b2106d20e..8ec8505f9d5d3597d8b49a628f6f0f5bff6e9e68 100644 (file)
--- a/src/librbd/crypto/luks/FlattenRequest.cc
+++ b/src/librbd/crypto/luks/FlattenRequest.cc
@@ -74,8 +74,9 @@ void FlattenRequest<I>::read_header() {
   ZTracer::Trace trace;
   auto req = io::ImageDispatchSpec::create_read(
           *m_image_ctx, io::IMAGE_DISPATCH_LAYER_API_START, aio_comp,
-          {{0, data_offset}}, io::ReadResult{&m_bl},
-          m_image_ctx->get_data_io_context(), 0, 0, trace);
+          {{0, data_offset}}, io::ImageArea::CRYPTO_HEADER,
+          io::ReadResult{&m_bl}, m_image_ctx->get_data_io_context(), 0, 0,
+          trace);
   req->send();
 }
 
@@ -121,8 +122,8 @@ void FlattenRequest<I>::write_header() {
   ZTracer::Trace trace;
   auto req = io::ImageDispatchSpec::create_write(
           *m_image_ctx, io::IMAGE_DISPATCH_LAYER_API_START, aio_comp,
-          {{0, m_bl.length()}}, std::move(m_bl),
-          m_image_ctx->get_data_io_context(), 0, trace);
+          {{0, m_bl.length()}}, io::ImageArea::CRYPTO_HEADER,
+          std::move(m_bl), m_image_ctx->get_data_io_context(), 0, trace);
   req->send();
 }
 

diff --git a/src/librbd/crypto/luks/FormatRequest.cc b/src/librbd/crypto/luks/FormatRequest.cc
index 659fffd3fd7643b400c75f214a886c25497305cf..30541cd3184000073180234fdcd94bc56e8dae54 100644 (file)
--- a/src/librbd/crypto/luks/FormatRequest.cc
+++ b/src/librbd/crypto/luks/FormatRequest.cc
@@ -167,7 +167,7 @@ void FormatRequest<I>::send() {
   ZTracer::Trace trace;
   auto req = io::ImageDispatchSpec::create_write(
           *m_image_ctx, io::IMAGE_DISPATCH_LAYER_API_START, aio_comp,
-          {{0, bl.length()}}, std::move(bl),
+          {{0, bl.length()}}, io::ImageArea::DATA, std::move(bl),
           m_image_ctx->get_data_io_context(), 0, trace);
   req->send();
 }

diff --git a/src/librbd/crypto/luks/LoadRequest.cc b/src/librbd/crypto/luks/LoadRequest.cc
index 61eaebdbefae25ed40cac2a9e2d53dc878fd04a0..b345cdbb824b5ecd10960dfe5bf18489048e26e7 100644 (file)
--- a/src/librbd/crypto/luks/LoadRequest.cc
+++ b/src/librbd/crypto/luks/LoadRequest.cc
@@ -59,7 +59,7 @@ void LoadRequest<I>::read(uint64_t end_offset, Context* on_finish) {
   ZTracer::Trace trace;
   auto req = io::ImageDispatchSpec::create_read(
           *m_image_ctx, io::IMAGE_DISPATCH_LAYER_API_START, aio_comp,
-          {{m_offset, length}}, io::ReadResult{&m_bl},
+          {{m_offset, length}}, io::ImageArea::DATA, io::ReadResult{&m_bl},
           m_image_ctx->get_data_io_context(), 0, 0, trace);
   req->send();
 }

diff --git a/src/librbd/deep_copy/ObjectCopyRequest.cc b/src/librbd/deep_copy/ObjectCopyRequest.cc
index 71e8f95a6a1c940316c399d64830d0c2b15c950d..c5b7a9674041ead6f3d1ae524fbc691ac714b847 100644 (file)
--- a/src/librbd/deep_copy/ObjectCopyRequest.cc
+++ b/src/librbd/deep_copy/ObjectCopyRequest.cc
@@ -105,8 +105,8 @@ void ObjectCopyRequest<I>::send_list_snaps() {
     ctx, get_image_ctx(m_src_image_ctx), io::AIO_TYPE_GENERIC);
   auto req = io::ImageDispatchSpec::create_list_snaps(
     *m_src_image_ctx, io::IMAGE_DISPATCH_LAYER_NONE, aio_comp,
-    io::Extents{m_image_extents}, std::move(snap_ids), list_snaps_flags,
-    &m_snapshot_delta, {});
+    io::Extents{m_image_extents}, m_image_area, std::move(snap_ids),
+    list_snaps_flags, &m_snapshot_delta, {});
   req->send();
 }
 
@@ -173,8 +173,8 @@ void ObjectCopyRequest<I>::send_read() {
 
   auto req = io::ImageDispatchSpec::create_read(
     *m_src_image_ctx, io::IMAGE_DISPATCH_LAYER_INTERNAL_START, aio_comp,
-    std::move(image_extents), std::move(read_result), io_context, op_flags,
-    read_flags, {});
+    std::move(image_extents), m_image_area, std::move(read_result),
+    io_context, op_flags, read_flags, {});
   req->send();
 }
 

diff --git a/src/librbd/internal.cc b/src/librbd/internal.cc
index 42542b22d28b4db9167b226ca639f5d71c98b90a..02d95d17d2ae1fbd4351676da50c87982da560f4 100644 (file)
--- a/src/librbd/internal.cc
+++ b/src/librbd/internal.cc
@@ -1348,7 +1348,7 @@ int validate_pool(IoCtx &io_ctx, CephContext *cct) {
        ctx, src, io::AIO_TYPE_READ);
       auto req = io::ImageDispatchSpec::create_read(
         *src, io::IMAGE_DISPATCH_LAYER_NONE, comp,
-        {{offset, len}}, io::ReadResult{bl},
+        {{offset, len}}, io::ImageArea::DATA, io::ReadResult{bl},
         src->get_data_io_context(), fadvise_flags, 0, trace);
 
       ctx->read_trace = trace;
@@ -1561,7 +1561,7 @@ int validate_pool(IoCtx &io_ctx, CephContext *cct) {
                                                    io::AIO_TYPE_READ);
       auto req = io::ImageDispatchSpec::create_read(
         *ictx, io::IMAGE_DISPATCH_LAYER_NONE, c,
-        {{off, read_len}}, io::ReadResult{&bl},
+        {{off, read_len}}, io::ImageArea::DATA, io::ReadResult{&bl},
         ictx->get_data_io_context(), 0, 0, trace);
       req->send();
 

diff --git a/src/librbd/io/CopyupRequest.cc b/src/librbd/io/CopyupRequest.cc
index 81847996d5a125e675c55b7d75f60074571ab304..3373fed3b2c55ea6ffe36bbc5709b43128221fa4 100644 (file)
--- a/src/librbd/io/CopyupRequest.cc
+++ b/src/librbd/io/CopyupRequest.cc
@@ -116,10 +116,10 @@ private:
 
 template <typename I>
 CopyupRequest<I>::CopyupRequest(I *ictx, uint64_t objectno,
-                                Extents &&image_extents,
+                                Extents &&image_extents, ImageArea area,
                                 const ZTracer::Trace &parent_trace)
   : m_image_ctx(ictx), m_object_no(objectno),
-    m_image_extents(std::move(image_extents)),
+    m_image_extents(std::move(image_extents)), m_image_area(area),
     m_trace(librbd::util::create_trace(*m_image_ctx, "copy-up", parent_trace))
 {
   ceph_assert(m_image_ctx->data_ctx.is_valid());
@@ -184,7 +184,7 @@ void CopyupRequest<I>::read_from_parent() {
                  << dendl;
   auto req = io::ImageDispatchSpec::create_read(
     *m_image_ctx->parent, io::IMAGE_DISPATCH_LAYER_INTERNAL_START, comp,
-    std::move(m_image_extents),
+    std::move(m_image_extents), m_image_area,
     ReadResult{&m_copyup_extent_map, &m_copyup_data},
     m_image_ctx->parent->get_data_io_context(), 0, 0, m_trace);
   req->send();

diff --git a/src/librbd/io/CopyupRequest.h b/src/librbd/io/CopyupRequest.h
index a6a20294c7f4bedbd5579c026b5e73f5557da5f8..a94139421c76c7f214f3cadde9559eedd7aa1e3b 100644 (file)
--- a/src/librbd/io/CopyupRequest.h
+++ b/src/librbd/io/CopyupRequest.h
@@ -30,13 +30,14 @@ template <typename ImageCtxT = librbd::ImageCtx>
 class CopyupRequest {
 public:
   static CopyupRequest* create(ImageCtxT *ictx, uint64_t objectno,
-                               Extents &&image_extents,
+                               Extents &&image_extents, ImageArea area,
                                const ZTracer::Trace &parent_trace) {
-    return new CopyupRequest(ictx, objectno, std::move(image_extents),
+    return new CopyupRequest(ictx, objectno, std::move(image_extents), area,
                              parent_trace);
   }
 
-  CopyupRequest(ImageCtxT *ictx, uint64_t objectno, Extents &&image_extents,
+  CopyupRequest(ImageCtxT *ictx, uint64_t objectno,
+                Extents &&image_extents, ImageArea area,
                 const ZTracer::Trace &parent_trace);
   ~CopyupRequest();
 
@@ -83,6 +84,7 @@ private:
   ImageCtxT *m_image_ctx;
   uint64_t m_object_no;
   Extents m_image_extents;
+  ImageArea m_image_area;
   ZTracer::Trace m_trace;
 
   bool m_flatten = false;

diff --git a/src/librbd/io/ImageDispatchSpec.h b/src/librbd/io/ImageDispatchSpec.h
index e4018ebcdbe0c694e5227a34c43ac71b4f26eeed..81bb3eeae0731e38fb1f1b88d210bd84aee1de9e 100644 (file)
--- a/src/librbd/io/ImageDispatchSpec.h
+++ b/src/librbd/io/ImageDispatchSpec.h
@@ -125,12 +125,12 @@ public:
   template <typename ImageCtxT = ImageCtx>
   static ImageDispatchSpec* create_read(
       ImageCtxT &image_ctx, ImageDispatchLayer image_dispatch_layer,
-      AioCompletion *aio_comp, Extents &&image_extents,
+      AioCompletion *aio_comp, Extents &&image_extents, ImageArea area,
       ReadResult &&read_result, IOContext io_context, int op_flags,
       int read_flags, const ZTracer::Trace &parent_trace) {
     return new ImageDispatchSpec(image_ctx.io_image_dispatcher,
                                  image_dispatch_layer, aio_comp,
-                                 std::move(image_extents),
+                                 std::move(image_extents), area,
                                  Read{std::move(read_result), read_flags},
                                  io_context, op_flags, parent_trace);
   }
@@ -138,12 +138,12 @@ public:
   template <typename ImageCtxT = ImageCtx>
   static ImageDispatchSpec* create_discard(
       ImageCtxT &image_ctx, ImageDispatchLayer image_dispatch_layer,
-      AioCompletion *aio_comp, Extents &&image_extents,
+      AioCompletion *aio_comp, Extents &&image_extents, ImageArea area,
       uint32_t discard_granularity_bytes, IOContext io_context,
       const ZTracer::Trace &parent_trace) {
     return new ImageDispatchSpec(image_ctx.io_image_dispatcher,
                                  image_dispatch_layer, aio_comp,
-                                 std::move(image_extents),
+                                 std::move(image_extents), area,
                                  Discard{discard_granularity_bytes},
                                  io_context, 0, parent_trace);
   }
@@ -151,24 +151,25 @@ public:
   template <typename ImageCtxT = ImageCtx>
   static ImageDispatchSpec* create_write(
       ImageCtxT &image_ctx, ImageDispatchLayer image_dispatch_layer,
-      AioCompletion *aio_comp, Extents &&image_extents,
+      AioCompletion *aio_comp, Extents &&image_extents, ImageArea area,
       bufferlist &&bl, IOContext io_context, int op_flags,
       const ZTracer::Trace &parent_trace) {
     return new ImageDispatchSpec(image_ctx.io_image_dispatcher,
                                  image_dispatch_layer, aio_comp,
-                                 std::move(image_extents), Write{std::move(bl)},
+                                 std::move(image_extents), area,
+                                 Write{std::move(bl)},
                                  io_context, op_flags, parent_trace);
   }
 
   template <typename ImageCtxT = ImageCtx>
   static ImageDispatchSpec* create_write_same(
       ImageCtxT &image_ctx, ImageDispatchLayer image_dispatch_layer,
-      AioCompletion *aio_comp, Extents &&image_extents,
+      AioCompletion *aio_comp, Extents &&image_extents, ImageArea area,
       bufferlist &&bl, IOContext io_context, int op_flags,
       const ZTracer::Trace &parent_trace) {
     return new ImageDispatchSpec(image_ctx.io_image_dispatcher,
                                  image_dispatch_layer, aio_comp,
-                                 std::move(image_extents),
+                                 std::move(image_extents), area,
                                  WriteSame{std::move(bl)},
                                  io_context, op_flags, parent_trace);
   }
@@ -176,12 +177,12 @@ public:
   template <typename ImageCtxT = ImageCtx>
   static ImageDispatchSpec* create_compare_and_write(
       ImageCtxT &image_ctx, ImageDispatchLayer image_dispatch_layer,
-      AioCompletion *aio_comp, Extents &&image_extents,
+      AioCompletion *aio_comp, 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) {
     return new ImageDispatchSpec(image_ctx.io_image_dispatcher,
                                  image_dispatch_layer, aio_comp,
-                                 std::move(image_extents),
+                                 std::move(image_extents), area,
                                  CompareAndWrite{std::move(cmp_bl),
                                                  std::move(bl),
                                                  mismatch_offset},
@@ -195,18 +196,19 @@ public:
       const ZTracer::Trace &parent_trace) {
     return new ImageDispatchSpec(image_ctx.io_image_dispatcher,
                                  image_dispatch_layer, aio_comp, {},
+                                 ImageArea::DATA /* dummy for {} */,
                                  Flush{flush_source}, {}, 0, parent_trace);
   }
 
   template <typename ImageCtxT = ImageCtx>
   static ImageDispatchSpec* create_list_snaps(
       ImageCtxT &image_ctx, ImageDispatchLayer image_dispatch_layer,
-      AioCompletion *aio_comp, Extents &&image_extents, SnapIds&& snap_ids,
-      int list_snaps_flags, SnapshotDelta* snapshot_delta,
+      AioCompletion *aio_comp, Extents &&image_extents, ImageArea area,
+      SnapIds&& snap_ids, int list_snaps_flags, SnapshotDelta* snapshot_delta,
       const ZTracer::Trace &parent_trace) {
     return new ImageDispatchSpec(image_ctx.io_image_dispatcher,
                                  image_dispatch_layer, aio_comp,
-                                 std::move(image_extents),
+                                 std::move(image_extents), area,
                                  ListSnaps{std::move(snap_ids),
                                            list_snaps_flags, snapshot_delta},
                                  {}, 0, parent_trace);
@@ -227,8 +229,8 @@ private:
   ImageDispatchSpec(ImageDispatcherInterface* image_dispatcher,
                     ImageDispatchLayer image_dispatch_layer,
                     AioCompletion* aio_comp, Extents&& image_extents,
-                    Request&& request, IOContext io_context, int op_flags,
-                    const ZTracer::Trace& parent_trace)
+                    ImageArea area, Request&& request, IOContext io_context,
+                    int op_flags, const ZTracer::Trace& parent_trace)
     : dispatcher_ctx(this), image_dispatcher(image_dispatcher),
       dispatch_layer(image_dispatch_layer), aio_comp(aio_comp),
       image_extents(std::move(image_extents)), request(std::move(request)),

diff --git a/src/librbd/io/ObjectRequest.cc b/src/librbd/io/ObjectRequest.cc
index eaf6ecfb13d948b2d096304323e4913000a216d4..0ce90e30de3bdf3cf0a71447717dc303de60eed8 100644 (file)
--- a/src/librbd/io/ObjectRequest.cc
+++ b/src/librbd/io/ObjectRequest.cc
@@ -343,7 +343,8 @@ void ObjectReadRequest<I>::copyup() {
   if (it == image_ctx->copyup_list.end()) {
     // create and kick off a CopyupRequest
     auto new_req = CopyupRequest<I>::create(
-      image_ctx, this->m_object_no, std::move(parent_extents), this->m_trace);
+        image_ctx, this->m_object_no, std::move(parent_extents), area,
+        this->m_trace);
 
     image_ctx->copyup_list[this->m_object_no] = new_req;
     image_ctx->copyup_list_lock.unlock();
@@ -569,8 +570,8 @@ void AbstractObjectWriteRequest<I>::copyup() {
   auto it = image_ctx->copyup_list.find(this->m_object_no);
   if (it == image_ctx->copyup_list.end()) {
     auto new_req = CopyupRequest<I>::create(
-      image_ctx, this->m_object_no, std::move(this->m_parent_extents),
-      this->m_trace);
+        image_ctx, this->m_object_no, std::move(this->m_parent_extents),
+        m_image_area, this->m_trace);
     this->m_parent_extents.clear();
 
     // make sure to wait on this CopyupRequest

diff --git a/src/librbd/io/Utils.cc b/src/librbd/io/Utils.cc
index ad725cc22f0c5f1dbc1a99e1158921f865e4ffc5..c5fa3484e237feaf3a847a4f7c908366675a1386 100644 (file)
--- a/src/librbd/io/Utils.cc
+++ b/src/librbd/io/Utils.cc
@@ -134,7 +134,7 @@ void read_parent(I *image_ctx, uint64_t object_no, ReadExtents* read_extents,
                  << " area=" << area << dendl;
   auto req = io::ImageDispatchSpec::create_read(
     *image_ctx->parent, io::IMAGE_DISPATCH_LAYER_INTERNAL_START, comp,
-    std::move(parent_extents), ReadResult{parent_read_bl},
+    std::move(parent_extents), area, ReadResult{parent_read_bl},
     image_ctx->parent->get_data_io_context(), 0, 0, trace);
   req->send();
 }

diff --git a/src/librbd/migration/NativeFormat.cc b/src/librbd/migration/NativeFormat.cc
index a7682619c1908711bf9cf3eba43dbf18778b0814..51248b95e26eae85955e77fa9b118a33bfd810fe 100644 (file)
--- a/src/librbd/migration/NativeFormat.cc
+++ b/src/librbd/migration/NativeFormat.cc
@@ -298,8 +298,8 @@ void NativeFormat<I>::list_snaps(io::Extents&& image_extents,
     on_finish, util::get_image_ctx(m_image_ctx), io::AIO_TYPE_GENERIC);
   auto req = io::ImageDispatchSpec::create_list_snaps(
     *m_image_ctx, io::IMAGE_DISPATCH_LAYER_MIGRATION, aio_comp,
-    std::move(image_extents), std::move(snap_ids), list_snaps_flags,
-    snapshot_delta, {});
+    std::move(image_extents), io::ImageArea::DATA, std::move(snap_ids),
+    list_snaps_flags, snapshot_delta, {});
   req->send();
 }
 

diff --git a/src/test/librbd/crypto/test_mock_CryptoObjectDispatch.cc b/src/test/librbd/crypto/test_mock_CryptoObjectDispatch.cc
index f0920f09d354d6d31a0f1538f6dc8df373a4516f..928d47a5311f43437a5a449683e0cda33d831ed9 100644 (file)
--- a/src/test/librbd/crypto/test_mock_CryptoObjectDispatch.cc
+++ b/src/test/librbd/crypto/test_mock_CryptoObjectDispatch.cc
@@ -39,9 +39,9 @@ struct CopyupRequest<librbd::MockImageCtx> {
             const Extents&));
 
     static CopyupRequest* s_instance;
-    static CopyupRequest* create(librbd::MockImageCtx *ictx,
-                                 uint64_t objectno, Extents &&image_extents,
-                                 const ZTracer::Trace &parent_trace) {
+    static CopyupRequest* create(librbd::MockImageCtx* ictx, uint64_t objectno,
+                                 Extents&& image_extents, ImageArea area,
+                                 const ZTracer::Trace& parent_trace) {
       return s_instance;
     }
 

diff --git a/src/test/librbd/io/test_mock_CopyupRequest.cc b/src/test/librbd/io/test_mock_CopyupRequest.cc
index 14d15cea1795856a8cc9b14d1d8554a1ecf3cb65..f7f2611490cfe61268be97533a064b82e48f3f42 100644 (file)
--- a/src/test/librbd/io/test_mock_CopyupRequest.cc
+++ b/src/test/librbd/io/test_mock_CopyupRequest.cc
@@ -428,8 +428,8 @@ TEST_F(TestMockIoCopyupRequest, Standard) {
                        {{0, 4096}}, data, 0);
   expect_write(mock_image_ctx, CEPH_NOSNAP, ictx->get_object_name(0), 0);
 
-  auto req = new MockCopyupRequest(&mock_image_ctx, 0,
-                                   {{0, 4096}}, {});
+  auto req = new MockCopyupRequest(&mock_image_ctx, 0, {{0, 4096}},
+                                   ImageArea::DATA, {});
   mock_image_ctx.copyup_list[0] = req;
   req->append_request(&mock_write_request, {});
   req->send();
@@ -485,8 +485,8 @@ TEST_F(TestMockIoCopyupRequest, StandardWithSnaps) {
                        data, 0);
   expect_write(mock_image_ctx, CEPH_NOSNAP, ictx->get_object_name(0), 0);
 
-  auto req = new MockCopyupRequest(&mock_image_ctx, 0,
-                                   {{0, 4096}}, {});
+  auto req = new MockCopyupRequest(&mock_image_ctx, 0, {{0, 4096}},
+                                   ImageArea::DATA, {});
   mock_image_ctx.copyup_list[0] = req;
   req->append_request(&mock_write_request, {});
   req->send();
@@ -525,8 +525,8 @@ TEST_F(TestMockIoCopyupRequest, CopyOnRead) {
   expect_sparse_copyup(mock_image_ctx, CEPH_NOSNAP, ictx->get_object_name(0),
                        {{0, 4096}}, data, 0);
 
-  auto req = new MockCopyupRequest(&mock_image_ctx, 0,
-                                   {{0, 4096}}, {});
+  auto req = new MockCopyupRequest(&mock_image_ctx, 0, {{0, 4096}},
+                                   ImageArea::DATA, {});
   mock_image_ctx.copyup_list[0] = req;
   req->send();
   flush_async_operations(ictx);
@@ -571,8 +571,8 @@ TEST_F(TestMockIoCopyupRequest, CopyOnReadWithSnaps) {
   expect_sparse_copyup(mock_image_ctx, 0, ictx->get_object_name(0), {{0, 4096}},
                        data, 0);
 
-  auto req = new MockCopyupRequest(&mock_image_ctx, 0,
-                                   {{0, 4096}}, {});
+  auto req = new MockCopyupRequest(&mock_image_ctx, 0, {{0, 4096}},
+                                   ImageArea::DATA, {});
   mock_image_ctx.copyup_list[0] = req;
   req->send();
   flush_async_operations(ictx);
@@ -617,8 +617,8 @@ TEST_F(TestMockIoCopyupRequest, DeepCopy) {
                        {}, "", 0);
   expect_write(mock_image_ctx, CEPH_NOSNAP, ictx->get_object_name(0), 0);
 
-  auto req = new MockCopyupRequest(&mock_image_ctx, 0,
-                                   {{0, 4096}}, {});
+  auto req = new MockCopyupRequest(&mock_image_ctx, 0, {{0, 4096}},
+                                   ImageArea::DATA, {});
   mock_image_ctx.copyup_list[0] = req;
   req->append_request(&mock_write_request, {});
   req->send();
@@ -655,8 +655,8 @@ TEST_F(TestMockIoCopyupRequest, DeepCopyOnRead) {
   expect_object_map_update(mock_image_ctx, CEPH_NOSNAP, 0, OBJECT_EXISTS, true,
                            0);
 
-  auto req = new MockCopyupRequest(&mock_image_ctx, 0,
-                                   {{0, 4096}}, {});
+  auto req = new MockCopyupRequest(&mock_image_ctx, 0, {{0, 4096}},
+                                   ImageArea::DATA, {});
   mock_image_ctx.copyup_list[0] = req;
   req->send();
   flush_async_operations(ictx);
@@ -722,8 +722,8 @@ TEST_F(TestMockIoCopyupRequest, DeepCopyWithPostSnaps) {
                        {}, "", 0);
   expect_write(mock_image_ctx, CEPH_NOSNAP, ictx->get_object_name(0), 0);
 
-  auto req = new MockCopyupRequest(&mock_image_ctx, 0,
-                                   {{0, 4096}}, {});
+  auto req = new MockCopyupRequest(&mock_image_ctx, 0, {{0, 4096}},
+                                   ImageArea::DATA, {});
   mock_image_ctx.copyup_list[0] = req;
   req->append_request(&mock_write_request, {});
   req->send();
@@ -794,8 +794,8 @@ TEST_F(TestMockIoCopyupRequest, DeepCopyWithPreAndPostSnaps) {
                        {}, "", 0);
   expect_write(mock_image_ctx, CEPH_NOSNAP, ictx->get_object_name(0), 0);
 
-  auto req = new MockCopyupRequest(&mock_image_ctx, 0,
-                                   {{0, 4096}}, {});
+  auto req = new MockCopyupRequest(&mock_image_ctx, 0, {{0, 4096}},
+                                   ImageArea::DATA, {});
   mock_image_ctx.copyup_list[0] = req;
   req->append_request(&mock_write_request, {});
   req->send();
@@ -836,8 +836,8 @@ TEST_F(TestMockIoCopyupRequest, ZeroedCopyup) {
                        {}, "", 0);
   expect_write(mock_image_ctx, CEPH_NOSNAP, ictx->get_object_name(0), 0);
 
-  auto req = new MockCopyupRequest(&mock_image_ctx, 0,
-                                   {{0, 4096}}, {});
+  auto req = new MockCopyupRequest(&mock_image_ctx, 0, {{0, 4096}},
+                                   ImageArea::DATA, {});
   mock_image_ctx.copyup_list[0] = req;
   req->append_request(&mock_write_request, {});
   req->send();
@@ -876,8 +876,8 @@ TEST_F(TestMockIoCopyupRequest, ZeroedCopyOnRead) {
   expect_sparse_copyup(mock_image_ctx, CEPH_NOSNAP, ictx->get_object_name(0),
                        {}, "", 0);
 
-  auto req = new MockCopyupRequest(&mock_image_ctx, 0,
-                                   {{0, 4096}}, {});
+  auto req = new MockCopyupRequest(&mock_image_ctx, 0, {{0, 4096}},
+                                   ImageArea::DATA, {});
   mock_image_ctx.copyup_list[0] = req;
   req->send();
   flush_async_operations(ictx);
@@ -910,8 +910,8 @@ TEST_F(TestMockIoCopyupRequest, NoOpCopyup) {
   MockAbstractObjectWriteRequest mock_write_request;
   expect_is_empty_write_op(mock_write_request, true);
 
-  auto req = new MockCopyupRequest(&mock_image_ctx, 0,
-                                   {{0, 4096}}, {});
+  auto req = new MockCopyupRequest(&mock_image_ctx, 0, {{0, 4096}},
+                                   ImageArea::DATA, {});
   mock_image_ctx.copyup_list[0] = req;
   req->append_request(&mock_write_request, {});
   req->send();
@@ -950,8 +950,8 @@ TEST_F(TestMockIoCopyupRequest, RestartWrite) {
   expect_object_map_update(mock_image_ctx, CEPH_NOSNAP, 0, OBJECT_EXISTS, true,
                            0);
 
-  auto req = new MockCopyupRequest(&mock_image_ctx, 0,
-                                   {{0, 4096}}, {});
+  auto req = new MockCopyupRequest(&mock_image_ctx, 0, {{0, 4096}},
+                                   ImageArea::DATA, {});
   expect_add_copyup_ops(mock_write_request1);
   expect_sparse_copyup(mock_image_ctx, CEPH_NOSNAP, ictx->get_object_name(0),
                        {{0, 4096}}, data, 0);
@@ -995,8 +995,8 @@ TEST_F(TestMockIoCopyupRequest, ReadFromParentError) {
 
   expect_read_parent(mock_parent_image_ctx, {{0, 4096}}, "", -EPERM);
 
-  auto req = new MockCopyupRequest(&mock_image_ctx, 0,
-                                   {{0, 4096}}, {});
+  auto req = new MockCopyupRequest(&mock_image_ctx, 0, {{0, 4096}},
+                                   ImageArea::DATA, {});
   mock_image_ctx.copyup_list[0] = req;
   MockAbstractObjectWriteRequest mock_write_request;
   req->append_request(&mock_write_request, {});
@@ -1029,8 +1029,8 @@ TEST_F(TestMockIoCopyupRequest, PrepareCopyupError) {
   expect_read_parent(mock_parent_image_ctx, {{0, 4096}}, data, 0);
   expect_prepare_copyup(mock_image_ctx, -EIO);
 
-  auto req = new MockCopyupRequest(&mock_image_ctx, 0,
-                                   {{0, 4096}}, {});
+  auto req = new MockCopyupRequest(&mock_image_ctx, 0, {{0, 4096}},
+                                   ImageArea::DATA, {});
   mock_image_ctx.copyup_list[0] = req;
   MockAbstractObjectWriteRequest mock_write_request;
   req->append_request(&mock_write_request, {});
@@ -1068,8 +1068,8 @@ TEST_F(TestMockIoCopyupRequest, DeepCopyError) {
 
   expect_is_empty_write_op(mock_write_request, false);
 
-  auto req = new MockCopyupRequest(&mock_image_ctx, 0,
-                                   {{0, 4096}}, {});
+  auto req = new MockCopyupRequest(&mock_image_ctx, 0, {{0, 4096}},
+                                   ImageArea::DATA, {});
   mock_image_ctx.copyup_list[0] = req;
   req->append_request(&mock_write_request, {});
   req->send();
@@ -1108,8 +1108,8 @@ TEST_F(TestMockIoCopyupRequest, UpdateObjectMapError) {
   expect_object_map_update(mock_image_ctx, CEPH_NOSNAP, 0, OBJECT_EXISTS, true,
                            -EINVAL);
 
-  auto req = new MockCopyupRequest(&mock_image_ctx, 0,
-                                   {{0, 4096}}, {});
+  auto req = new MockCopyupRequest(&mock_image_ctx, 0, {{0, 4096}},
+                                   ImageArea::DATA, {});
   mock_image_ctx.copyup_list[0] = req;
   req->append_request(&mock_write_request, {});
   req->send();
@@ -1161,8 +1161,8 @@ TEST_F(TestMockIoCopyupRequest, CopyupError) {
                        data, -EPERM);
   expect_write(mock_image_ctx, CEPH_NOSNAP, ictx->get_object_name(0), 0);
 
-  auto req = new MockCopyupRequest(&mock_image_ctx, 0,
-                                   {{0, 4096}}, {});
+  auto req = new MockCopyupRequest(&mock_image_ctx, 0, {{0, 4096}},
+                                   ImageArea::DATA, {});
   mock_image_ctx.copyup_list[0] = req;
   req->append_request(&mock_write_request, {});
   req->send();
@@ -1207,7 +1207,8 @@ TEST_F(TestMockIoCopyupRequest, SparseCopyupNotSupported) {
   expect_copyup(mock_image_ctx, CEPH_NOSNAP, ictx->get_object_name(0), data, 0);
   expect_write(mock_image_ctx, CEPH_NOSNAP, ictx->get_object_name(0), 0);
 
-  auto req = new MockCopyupRequest(&mock_image_ctx, 0, {{0, 4096}}, {});
+  auto req = new MockCopyupRequest(&mock_image_ctx, 0, {{0, 4096}},
+                                   ImageArea::DATA, {});
   mock_image_ctx.copyup_list[0] = req;
   req->append_request(&mock_write_request, {});
   req->send();
@@ -1261,8 +1262,8 @@ TEST_F(TestMockIoCopyupRequest, ProcessCopyup) {
                        {{2048, 1024}}, data.substr(0, 1024), 0);
   expect_write(mock_image_ctx, CEPH_NOSNAP, ictx->get_object_name(0), 0);
 
-  auto req = new MockCopyupRequest(&mock_image_ctx, 0,
-                                   {{0, 4096}}, {});
+  auto req = new MockCopyupRequest(&mock_image_ctx, 0, {{0, 4096}},
+                                   ImageArea::DATA, {});
   mock_image_ctx.copyup_list[0] = req;
   req->append_request(&mock_write_request, {{0, 1024}});
   req->send();
@@ -1325,8 +1326,8 @@ TEST_F(TestMockIoCopyupRequest, ProcessCopyupOverwrite) {
                        {{0, 1024}, {2048, 1024}}, data.substr(0, 2048), 0);
   expect_write(mock_image_ctx, CEPH_NOSNAP, ictx->get_object_name(0), 0);
 
-  auto req = new MockCopyupRequest(&mock_image_ctx, 0,
-                                   {{0, 4096}}, {});
+  auto req = new MockCopyupRequest(&mock_image_ctx, 0, {{0, 4096}},
+                                   ImageArea::DATA, {});
   mock_image_ctx.copyup_list[0] = req;
   req->append_request(&mock_write_request, {{0, 1024}});
   req->send();

diff --git a/src/test/librbd/io/test_mock_ObjectRequest.cc b/src/test/librbd/io/test_mock_ObjectRequest.cc
index f8dc2841fd37eaad10b2a8dd7fbd8736d5690fa5..38ac506c4f85271d5c9012304acce0532e485bec 100644 (file)
--- a/src/test/librbd/io/test_mock_ObjectRequest.cc
+++ b/src/test/librbd/io/test_mock_ObjectRequest.cc
@@ -46,7 +46,8 @@ struct CopyupRequest<librbd::MockTestImageCtx> : public CopyupRequest<librbd::Mo
   static CopyupRequest* s_instance;
   static CopyupRequest* create(librbd::MockTestImageCtx *ictx,
                                uint64_t objectno, Extents &&image_extents,
-                               const ZTracer::Trace &parent_trace) {
+                               ImageArea area,
+                               const ZTracer::Trace& parent_trace) {
     return s_instance;
   }