RepoMirrors/ceph
1
0
Fork 0
mirror of https://github.com/ceph/ceph synced 2025-02-23 19:17:37 +00:00
Code Issues Packages Projects Releases Wiki Activity

librbd: propagate area down to file_to_extents()

Browse Source 
- 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>
This commit is contained in:
Ilya Dryomov 2022-09-14 14:55:56 +02:00
parent be286db1f1
commit b9a2384cdc
17 changed files with 230 additions and 163 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
src/librbd/cache/WriteLogImageDispatch.cc vendored
View File

@ -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;

10
src/librbd/deep_copy/ObjectCopyRequest.cc
View File

@ -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);

10
src/librbd/io/CopyupRequest.cc
View File

@ -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);

67
src/librbd/io/ImageDispatch.cc
View File

@ -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;
}

10
src/librbd/io/ImageDispatchSpec.h
View File

@ -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();
}
}
};

57
src/librbd/io/ImageRequest.cc
View File

@ -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);

87
src/librbd/io/ImageRequest.h
View File

@ -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 {}

7
src/librbd/io/ObjectRequest.cc
View File

@ -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(

4
src/librbd/io/Types.h
View File

@ -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 {

17
src/librbd/io/Utils.cc
View File

@ -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>;

9
src/librbd/io/Utils.h
View File

@ -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(

6
src/librbd/journal/Replay.cc
View File

@ -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,

9
src/test/librbd/deep_copy/test_mock_ObjectCopyRequest.cc
View File

@ -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);
}

9
src/test/librbd/io/test_mock_CopyupRequest.cc
View File

@ -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);
}

42
src/test/librbd/io/test_mock_ImageRequest.cc
View File

@ -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();

14
src/test/librbd/io/test_mock_ObjectRequest.cc
View File

@ -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);
}

15
src/test/librbd/journal/test_mock_Replay.cc
View File

@ -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);