auto req = io::ImageDispatchSpec::create_read(
image_ctx, io::IMAGE_DISPATCH_LAYER_API_START, aio_comp, {{off, len}},
- std::move(read_result), op_flags, trace);
+ std::move(read_result), image_ctx.get_data_io_context(), op_flags, trace);
req->send();
}
auto req = io::ImageDispatchSpec::create_write(
image_ctx, io::IMAGE_DISPATCH_LAYER_API_START, aio_comp, {{off, len}},
- std::move(bl), op_flags, trace);
+ std::move(bl), image_ctx.get_data_io_context(), op_flags, trace);
req->send();
}
auto req = io::ImageDispatchSpec::create_discard(
image_ctx, io::IMAGE_DISPATCH_LAYER_API_START, aio_comp, off, len,
- discard_granularity_bytes, trace);
+ discard_granularity_bytes, image_ctx.get_data_io_context(), trace);
req->send();
}
auto req = io::ImageDispatchSpec::create_write_same(
image_ctx, io::IMAGE_DISPATCH_LAYER_API_START, aio_comp, off, len,
- std::move(bl), op_flags, trace);
+ std::move(bl), image_ctx.get_data_io_context(), op_flags, trace);
req->send();
}
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), op_flags, trace);
+ std::move(bl), image_ctx.get_data_io_context(), op_flags, trace);
req->send();
return;
} else if (prepend_length == 0 && append_length == 0) {
auto req = io::ImageDispatchSpec::create_write_same(
image_ctx, io::IMAGE_DISPATCH_LAYER_API_START, aio_comp, off, len,
- std::move(bl), op_flags, trace);
+ std::move(bl), image_ctx.get_data_io_context(), op_flags, trace);
req->send();
return;
}
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), op_flags, trace);
+ {{prepend_offset, prepend_length}}, std::move(bl),
+ image_ctx.get_data_io_context(), op_flags, trace);
prepend_req->send();
}
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), op_flags, trace);
+ {{append_offset, append_length}}, std::move(bl),
+ image_ctx.get_data_io_context(), op_flags, trace);
append_req->send();
}
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), op_flags, trace);
+ write_same_offset, write_same_length, std::move(bl),
+ image_ctx.get_data_io_context(), op_flags, trace);
req->send();
return;
}
auto req = io::ImageDispatchSpec::create_discard(
image_ctx, io::IMAGE_DISPATCH_LAYER_API_START, aio_comp, off, len,
- discard_granularity_bytes, trace);
+ discard_granularity_bytes, image_ctx.get_data_io_context(), trace);
req->send();
}
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, op_flags, trace);
+ std::move(cmp_bl), std::move(bl), mismatch_off,
+ image_ctx.get_data_io_context(), op_flags, trace);
req->send();
}
auto aio_comp = io::AioCompletion::create_and_start(
on_finish, image_ctx, io::AIO_TYPE_READ);
io::ImageReadRequest<> req(*image_ctx, aio_comp, std::move(image_extents),
- io::ReadResult{bl}, fadvise_flags, {});
+ io::ReadResult{bl},
+ image_ctx->get_data_io_context(), fadvise_flags,
+ {});
req.set_bypass_image_cache();
req.send();
}
auto aio_comp = io::AioCompletion::create_and_start(
on_finish, image_ctx, io::AIO_TYPE_WRITE);
io::ImageWriteRequest<> req(*image_ctx, aio_comp, std::move(image_extents),
- std::move(bl), fadvise_flags, {});
+ std::move(bl), image_ctx->get_data_io_context(),
+ fadvise_flags, {});
req.set_bypass_image_cache();
req.send();
}
auto aio_comp = io::AioCompletion::create_and_start(
on_finish, image_ctx, io::AIO_TYPE_DISCARD);
io::ImageDiscardRequest<> req(*image_ctx, aio_comp, {{offset, length}},
- discard_granularity_bytes, {});
+ discard_granularity_bytes,
+ image_ctx->get_data_io_context(), {});
req.set_bypass_image_cache();
req.send();
}
template <typename I>
-void ImageWriteback<I>::aio_flush(io::FlushSource flush_source, Context *on_finish) {
+void ImageWriteback<I>::aio_flush(io::FlushSource flush_source,
+ Context *on_finish) {
CephContext *cct = m_image_ctx.cct;
ldout(cct, 20) << "on_finish=" << on_finish << dendl;
auto aio_comp = io::AioCompletion::create_and_start(
on_finish, image_ctx, io::AIO_TYPE_WRITESAME);
io::ImageWriteSameRequest<> req(*image_ctx, aio_comp, {{offset, length}},
- std::move(bl), fadvise_flags, {});
+ std::move(bl),
+ image_ctx->get_data_io_context(),
+ fadvise_flags, {});
req.set_bypass_image_cache();
req.send();
}
auto aio_comp = io::AioCompletion::create_and_start(
on_finish, image_ctx, io::AIO_TYPE_COMPARE_AND_WRITE);
io::ImageCompareAndWriteRequest<> req(*image_ctx, aio_comp,
- std::move(image_extents),
- std::move(cmp_bl), std::move(bl),
- mismatch_offset, fadvise_flags, {});
+ std::move(image_extents),
+ std::move(cmp_bl), std::move(bl),
+ mismatch_offset,
+ image_ctx->get_data_io_context(),
+ fadvise_flags, {});
req.set_bypass_image_cache();
req.send();
}
auto src_image_ctx = m_src_image_ctx;
io::ImageRequest<I>::aio_read(src_image_ctx->parent, comp,
std::move(image_extents),
- io::ReadResult{&m_read_from_parent_data}, 0,
+ io::ReadResult{&m_read_from_parent_data},
+ src_image_ctx->get_data_io_context(), 0,
ZTracer::Trace());
}
template <typename I>
bool ImageDispatch<I>::read(
io::AioCompletion* aio_comp, io::Extents &&image_extents,
- io::ReadResult &&read_result, int op_flags,
+ io::ReadResult &&read_result, IOContext io_context, int op_flags,
const ZTracer::Trace &parent_trace, uint64_t tid,
std::atomic<uint32_t>* image_dispatch_flags,
io::DispatchResult* dispatch_result, Context** on_finish,
template <typename I>
bool ImageDispatch<I>::write(
io::AioCompletion* aio_comp, io::Extents &&image_extents, bufferlist &&bl,
- int op_flags, const ZTracer::Trace &parent_trace, uint64_t tid,
- std::atomic<uint32_t>* image_dispatch_flags,
+ IOContext io_context, int op_flags, const ZTracer::Trace &parent_trace,
+ uint64_t tid, std::atomic<uint32_t>* image_dispatch_flags,
io::DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) {
auto cct = m_image_ctx->cct;
template <typename I>
bool ImageDispatch<I>::discard(
io::AioCompletion* aio_comp, io::Extents &&image_extents,
- uint32_t discard_granularity_bytes, const ZTracer::Trace &parent_trace,
- uint64_t tid, std::atomic<uint32_t>* image_dispatch_flags,
+ uint32_t discard_granularity_bytes, IOContext io_context,
+ const ZTracer::Trace &parent_trace, uint64_t tid,
+ std::atomic<uint32_t>* image_dispatch_flags,
io::DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) {
auto cct = m_image_ctx->cct;
template <typename I>
bool ImageDispatch<I>::write_same(
io::AioCompletion* aio_comp, io::Extents &&image_extents, bufferlist &&bl,
- int op_flags, const ZTracer::Trace &parent_trace, uint64_t tid,
- std::atomic<uint32_t>* image_dispatch_flags,
+ IOContext io_context, int op_flags, const ZTracer::Trace &parent_trace,
+ uint64_t tid, std::atomic<uint32_t>* image_dispatch_flags,
io::DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) {
auto cct = m_image_ctx->cct;
bool ImageDispatch<I>::compare_and_write(
io::AioCompletion* aio_comp, io::Extents &&image_extents,
bufferlist &&cmp_bl, bufferlist &&bl, uint64_t *mismatch_offset,
- int op_flags, const ZTracer::Trace &parent_trace, uint64_t tid,
- std::atomic<uint32_t>* image_dispatch_flags,
+ IOContext io_context, int op_flags, const ZTracer::Trace &parent_trace,
+ uint64_t tid, std::atomic<uint32_t>* image_dispatch_flags,
io::DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) {
auto cct = m_image_ctx->cct;
bool read(
io::AioCompletion* aio_comp, io::Extents &&image_extents,
- io::ReadResult &&read_result, int op_flags,
+ io::ReadResult &&read_result, IOContext io_context, int op_flags,
const ZTracer::Trace &parent_trace, uint64_t tid,
std::atomic<uint32_t>* image_dispatch_flags,
io::DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) override;
bool write(
io::AioCompletion* aio_comp, io::Extents &&image_extents, bufferlist &&bl,
- int op_flags, const ZTracer::Trace &parent_trace, uint64_t tid,
- std::atomic<uint32_t>* image_dispatch_flags,
+ IOContext io_context, int op_flags, const ZTracer::Trace &parent_trace,
+ uint64_t tid, std::atomic<uint32_t>* image_dispatch_flags,
io::DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) override;
bool discard(
io::AioCompletion* aio_comp, io::Extents &&image_extents,
- uint32_t discard_granularity_bytes,
+ uint32_t discard_granularity_bytes, IOContext io_context,
const ZTracer::Trace &parent_trace, uint64_t tid,
std::atomic<uint32_t>* image_dispatch_flags,
io::DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) override;
bool write_same(
io::AioCompletion* aio_comp, io::Extents &&image_extents, bufferlist &&bl,
- int op_flags, const ZTracer::Trace &parent_trace, uint64_t tid,
- std::atomic<uint32_t>* image_dispatch_flags,
+ IOContext io_context, int op_flags, const ZTracer::Trace &parent_trace,
+ uint64_t tid, std::atomic<uint32_t>* image_dispatch_flags,
io::DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) override;
bool compare_and_write(
io::AioCompletion* aio_comp, io::Extents &&image_extents,
bufferlist &&cmp_bl, bufferlist &&bl, uint64_t *mismatch_offset,
- int op_flags, const ZTracer::Trace &parent_trace, uint64_t tid,
- std::atomic<uint32_t>* image_dispatch_flags,
+ IOContext io_context, int op_flags, const ZTracer::Trace &parent_trace,
+ uint64_t tid, std::atomic<uint32_t>* image_dispatch_flags,
io::DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) override;
bool flush(
ctx, src, io::AIO_TYPE_READ);
io::ImageReadRequest<> req(*src, comp, {{offset, len}},
- io::ReadResult{bl}, fadvise_flags,
- std::move(trace));
+ io::ReadResult{bl}, src->get_data_io_context(),
+ fadvise_flags, std::move(trace));
ctx->read_trace = req.get_trace();
req.send();
auto c = io::AioCompletion::create_and_start(&ctx, ictx,
io::AIO_TYPE_READ);
io::ImageRequest<>::aio_read(ictx, c, {{off, read_len}},
- io::ReadResult{&bl}, 0, std::move(trace));
+ io::ReadResult{&bl},
+ ictx->get_data_io_context(), 0,
+ std::move(trace));
int ret = ctx.wait();
if (ret < 0) {
if (m_image_ctx->enable_sparse_copyup) {
ImageRequest<I>::aio_read(
m_image_ctx->parent, comp, std::move(m_image_extents),
- ReadResult{&m_copyup_extent_map, &m_copyup_data}, 0, m_trace);
+ ReadResult{&m_copyup_extent_map, &m_copyup_data},
+ m_image_ctx->parent->get_data_io_context(), 0, m_trace);
} else {
ImageRequest<I>::aio_read(
m_image_ctx->parent, comp, std::move(m_image_extents),
- ReadResult{&m_copyup_data}, 0, m_trace);
+ ReadResult{&m_copyup_data},
+ m_image_ctx->parent->get_data_io_context(), 0, m_trace);
}
}
template <typename I>
bool ImageDispatch<I>::read(
AioCompletion* aio_comp, Extents &&image_extents, ReadResult &&read_result,
- int op_flags, const ZTracer::Trace &parent_trace, uint64_t tid,
- std::atomic<uint32_t>* image_dispatch_flags,
+ IOContext io_context, int op_flags, const ZTracer::Trace &parent_trace,
+ uint64_t tid, std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) {
auto cct = m_image_ctx->cct;
*dispatch_result = DISPATCH_RESULT_COMPLETE;
ImageRequest<I>::aio_read(
m_image_ctx, aio_comp, std::move(image_extents), std::move(read_result),
- op_flags, parent_trace);
+ io_context, op_flags, parent_trace);
return true;
}
template <typename I>
bool ImageDispatch<I>::write(
AioCompletion* aio_comp, Extents &&image_extents, bufferlist &&bl,
- int op_flags, const ZTracer::Trace &parent_trace, uint64_t tid,
- std::atomic<uint32_t>* image_dispatch_flags,
+ IOContext io_context, int op_flags, const ZTracer::Trace &parent_trace,
+ uint64_t tid, std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) {
auto cct = m_image_ctx->cct;
*dispatch_result = DISPATCH_RESULT_COMPLETE;
ImageRequest<I>::aio_write(
- m_image_ctx, aio_comp, std::move(image_extents), std::move(bl), op_flags,
- parent_trace);
+ m_image_ctx, aio_comp, std::move(image_extents), std::move(bl),
+ io_context, op_flags, parent_trace);
return true;
}
template <typename I>
bool ImageDispatch<I>::discard(
AioCompletion* aio_comp, Extents &&image_extents,
- uint32_t discard_granularity_bytes, const ZTracer::Trace &parent_trace,
- uint64_t tid, std::atomic<uint32_t>* image_dispatch_flags,
+ uint32_t discard_granularity_bytes, IOContext io_context,
+ const ZTracer::Trace &parent_trace, uint64_t tid,
+ std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) {
auto cct = m_image_ctx->cct;
*dispatch_result = DISPATCH_RESULT_COMPLETE;
ImageRequest<I>::aio_discard(
m_image_ctx, aio_comp, std::move(image_extents), discard_granularity_bytes,
- parent_trace);
+ io_context, parent_trace);
return true;
}
template <typename I>
bool ImageDispatch<I>::write_same(
AioCompletion* aio_comp, Extents &&image_extents, bufferlist &&bl,
- int op_flags, const ZTracer::Trace &parent_trace, uint64_t tid,
- std::atomic<uint32_t>* image_dispatch_flags,
+ IOContext io_context, int op_flags, const ZTracer::Trace &parent_trace,
+ uint64_t tid, std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) {
auto cct = m_image_ctx->cct;
*dispatch_result = DISPATCH_RESULT_COMPLETE;
ImageRequest<I>::aio_writesame(
- m_image_ctx, aio_comp, std::move(image_extents), std::move(bl), op_flags,
- parent_trace);
+ m_image_ctx, aio_comp, std::move(image_extents), std::move(bl),
+ io_context, op_flags, parent_trace);
return true;
}
template <typename I>
bool ImageDispatch<I>::compare_and_write(
AioCompletion* aio_comp, Extents &&image_extents, bufferlist &&cmp_bl,
- bufferlist &&bl, uint64_t *mismatch_offset, int op_flags,
- const ZTracer::Trace &parent_trace, uint64_t tid,
+ bufferlist &&bl, uint64_t *mismatch_offset, IOContext io_context,
+ int op_flags, const ZTracer::Trace &parent_trace, uint64_t tid,
std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) {
*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, op_flags, parent_trace);
+ std::move(bl), mismatch_offset, io_context, op_flags, parent_trace);
return true;
}
bool read(
AioCompletion* aio_comp, Extents &&image_extents,
- ReadResult &&read_result, int op_flags,
+ ReadResult &&read_result, IOContext io_context, int op_flags,
const ZTracer::Trace &parent_trace, uint64_t tid,
std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) override;
bool write(
AioCompletion* aio_comp, Extents &&image_extents, bufferlist &&bl,
- int op_flags, const ZTracer::Trace &parent_trace, uint64_t tid,
- std::atomic<uint32_t>* image_dispatch_flags,
+ IOContext io_context, int op_flags, const ZTracer::Trace &parent_trace,
+ uint64_t tid, std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) override;
bool discard(
AioCompletion* aio_comp, Extents &&image_extents,
- uint32_t discard_granularity_bytes,
+ uint32_t discard_granularity_bytes, IOContext io_context,
const ZTracer::Trace &parent_trace, uint64_t tid,
std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) override;
bool write_same(
AioCompletion* aio_comp, Extents &&image_extents, bufferlist &&bl,
- int op_flags, const ZTracer::Trace &parent_trace, uint64_t tid,
- std::atomic<uint32_t>* image_dispatch_flags,
+ IOContext io_context, int op_flags, const ZTracer::Trace &parent_trace,
+ uint64_t tid, std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) override;
bool compare_and_write(
AioCompletion* aio_comp, Extents &&image_extents, bufferlist &&cmp_bl,
- bufferlist &&bl, uint64_t *mismatch_offset, int op_flags,
- const ZTracer::Trace &parent_trace, uint64_t tid,
+ bufferlist &&bl, uint64_t *mismatch_offset, IOContext io_context,
+ int op_flags, const ZTracer::Trace &parent_trace, uint64_t tid,
std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) override;
#include "include/int_types.h"
#include "include/buffer.h"
#include "common/zipkin_trace.h"
+#include "librbd/Types.h"
#include "librbd/io/ReadResult.h"
#include "librbd/io/Types.h"
#include <atomic>
virtual bool read(
AioCompletion* aio_comp, Extents &&image_extents,
- ReadResult &&read_result, int op_flags,
+ ReadResult &&read_result, IOContext io_context, int op_flags,
const ZTracer::Trace &parent_trace, uint64_t tid,
std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) = 0;
virtual bool write(
AioCompletion* aio_comp, Extents &&image_extents, bufferlist &&bl,
- int op_flags, const ZTracer::Trace &parent_trace, uint64_t tid,
- std::atomic<uint32_t>* image_dispatch_flags,
+ IOContext io_context, int op_flags, const ZTracer::Trace &parent_trace,
+ uint64_t tid, std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) = 0;
virtual bool discard(
AioCompletion* aio_comp, Extents &&image_extents,
uint32_t discard_granularity_bytes,
- const ZTracer::Trace &parent_trace, uint64_t tid,
+ IOContext io_context, const ZTracer::Trace &parent_trace, uint64_t tid,
std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) = 0;
virtual bool write_same(
AioCompletion* aio_comp, Extents &&image_extents, bufferlist &&bl,
- int op_flags, const ZTracer::Trace &parent_trace, uint64_t tid,
- std::atomic<uint32_t>* image_dispatch_flags,
+ IOContext io_context, int op_flags, const ZTracer::Trace &parent_trace,
+ uint64_t tid, std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) = 0;
virtual bool compare_and_write(
AioCompletion* aio_comp, Extents &&image_extents, bufferlist &&cmp_bl,
- bufferlist &&bl, uint64_t *mismatch_offset, int op_flags,
- const ZTracer::Trace &parent_trace, uint64_t tid,
+ bufferlist &&bl, uint64_t *mismatch_offset, IOContext io_context,
+ int op_flags, const ZTracer::Trace &parent_trace, uint64_t tid,
std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) = 0;
AioCompletion* aio_comp;
Extents image_extents;
Request request;
+ IOContext io_context;
int op_flags;
ZTracer::Trace parent_trace;
uint64_t tid = 0;
static ImageDispatchSpec* create_read(
ImageCtxT &image_ctx, ImageDispatchLayer image_dispatch_layer,
AioCompletion *aio_comp, Extents &&image_extents,
- ReadResult &&read_result, int op_flags,
+ ReadResult &&read_result, 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),
Read{std::move(read_result)},
- op_flags, parent_trace);
+ io_context, op_flags, parent_trace);
}
template <typename ImageCtxT = ImageCtx>
static ImageDispatchSpec* create_discard(
ImageCtxT &image_ctx, ImageDispatchLayer image_dispatch_layer,
AioCompletion *aio_comp, uint64_t off, uint64_t len,
- uint32_t discard_granularity_bytes, const ZTracer::Trace &parent_trace) {
+ 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, {{off, len}},
Discard{discard_granularity_bytes},
- 0, parent_trace);
+ io_context, 0, parent_trace);
}
template <typename ImageCtxT = ImageCtx>
static ImageDispatchSpec* create_write(
ImageCtxT &image_ctx, ImageDispatchLayer image_dispatch_layer,
AioCompletion *aio_comp, Extents &&image_extents,
- bufferlist &&bl, int op_flags, const ZTracer::Trace &parent_trace) {
+ 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)},
- op_flags, parent_trace);
+ 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, uint64_t off, uint64_t len,
- bufferlist &&bl, int op_flags, const ZTracer::Trace &parent_trace) {
+ 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,
{{off, len}}, WriteSame{std::move(bl)},
- op_flags, parent_trace);
+ io_context, op_flags, parent_trace);
}
template <typename ImageCtxT = ImageCtx>
ImageCtxT &image_ctx, ImageDispatchLayer image_dispatch_layer,
AioCompletion *aio_comp, Extents &&image_extents,
bufferlist &&cmp_bl, bufferlist &&bl, uint64_t *mismatch_offset,
- int op_flags, const ZTracer::Trace &parent_trace) {
+ 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),
CompareAndWrite{std::move(cmp_bl),
std::move(bl),
mismatch_offset},
- op_flags, parent_trace);
+ io_context, op_flags, parent_trace);
}
template <typename ImageCtxT = ImageCtx>
const ZTracer::Trace &parent_trace) {
return new ImageDispatchSpec(image_ctx.io_image_dispatcher,
image_dispatch_layer, aio_comp, {},
- Flush{flush_source}, 0, parent_trace);
+ Flush{flush_source}, {}, 0, parent_trace);
}
~ImageDispatchSpec() {
ImageDispatchSpec(ImageDispatcherInterface* image_dispatcher,
ImageDispatchLayer image_dispatch_layer,
AioCompletion* aio_comp, Extents&& image_extents,
- Request&& request, int op_flags,
+ 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)),
- op_flags(op_flags), parent_trace(parent_trace) {
+ io_context(io_context), op_flags(op_flags), parent_trace(parent_trace) {
aio_comp->image_dispatcher_ctx = &dispatcher_ctx;
aio_comp->get();
}
return image_dispatch->read(
image_dispatch_spec->aio_comp,
std::move(image_dispatch_spec->image_extents),
- std::move(read.read_result), image_dispatch_spec->op_flags,
- image_dispatch_spec->parent_trace, image_dispatch_spec->tid,
+ std::move(read.read_result), image_dispatch_spec->io_context,
+ image_dispatch_spec->op_flags, image_dispatch_spec->parent_trace,
+ image_dispatch_spec->tid,
&image_dispatch_spec->image_dispatch_flags,
&image_dispatch_spec->dispatch_result,
&image_dispatch_spec->aio_comp->image_dispatcher_ctx,
return image_dispatch->discard(
image_dispatch_spec->aio_comp,
std::move(image_dispatch_spec->image_extents),
- discard.discard_granularity_bytes,
+ discard.discard_granularity_bytes, image_dispatch_spec->io_context,
image_dispatch_spec->parent_trace, image_dispatch_spec->tid,
&image_dispatch_spec->image_dispatch_flags,
&image_dispatch_spec->dispatch_result,
return image_dispatch->write(
image_dispatch_spec->aio_comp,
std::move(image_dispatch_spec->image_extents), std::move(write.bl),
- image_dispatch_spec->op_flags, image_dispatch_spec->parent_trace,
- image_dispatch_spec->tid, &image_dispatch_spec->image_dispatch_flags,
+ image_dispatch_spec->io_context, image_dispatch_spec->op_flags,
+ image_dispatch_spec->parent_trace, image_dispatch_spec->tid,
+ &image_dispatch_spec->image_dispatch_flags,
&image_dispatch_spec->dispatch_result,
&image_dispatch_spec->aio_comp->image_dispatcher_ctx,
&image_dispatch_spec->dispatcher_ctx);
return image_dispatch->write_same(
image_dispatch_spec->aio_comp,
std::move(image_dispatch_spec->image_extents), std::move(write_same.bl),
- image_dispatch_spec->op_flags, image_dispatch_spec->parent_trace,
- image_dispatch_spec->tid, &image_dispatch_spec->image_dispatch_flags,
+ image_dispatch_spec->io_context, image_dispatch_spec->op_flags,
+ image_dispatch_spec->parent_trace, image_dispatch_spec->tid,
+ &image_dispatch_spec->image_dispatch_flags,
&image_dispatch_spec->dispatch_result,
&image_dispatch_spec->aio_comp->image_dispatcher_ctx,
&image_dispatch_spec->dispatcher_ctx);
image_dispatch_spec->aio_comp,
std::move(image_dispatch_spec->image_extents),
std::move(compare_and_write.cmp_bl), std::move(compare_and_write.bl),
- compare_and_write.mismatch_offset, image_dispatch_spec->op_flags,
- image_dispatch_spec->parent_trace, image_dispatch_spec->tid,
- &image_dispatch_spec->image_dispatch_flags,
+ compare_and_write.mismatch_offset, image_dispatch_spec->io_context,
+ image_dispatch_spec->op_flags, image_dispatch_spec->parent_trace,
+ image_dispatch_spec->tid, &image_dispatch_spec->image_dispatch_flags,
&image_dispatch_spec->dispatch_result,
&image_dispatch_spec->aio_comp->image_dispatcher_ctx,
&image_dispatch_spec->dispatcher_ctx);
};
template <typename I>
-void readahead(I *ictx, const Extents& image_extents) {
+void readahead(I *ictx, const Extents& image_extents, IOContext io_context) {
uint64_t total_bytes = 0;
for (auto& image_extent : image_extents) {
total_bytes += image_extent.second;
uint64_t image_size = ictx->get_image_size(ictx->snap_id);
ictx->image_lock.unlock_shared();
- auto io_context = ictx->get_data_io_context();
-
auto readahead_extent = ictx->readahead.update(image_extents, image_size);
uint64_t readahead_offset = readahead_extent.first;
uint64_t readahead_length = readahead_extent.second;
template <typename I>
void ImageRequest<I>::aio_read(I *ictx, AioCompletion *c,
Extents &&image_extents,
- ReadResult &&read_result, int op_flags,
+ ReadResult &&read_result, IOContext io_context,
+ int op_flags,
const ZTracer::Trace &parent_trace) {
ImageReadRequest<I> req(*ictx, c, std::move(image_extents),
- std::move(read_result), op_flags, parent_trace);
+ std::move(read_result), io_context, op_flags,
+ parent_trace);
req.send();
}
template <typename I>
void ImageRequest<I>::aio_write(I *ictx, AioCompletion *c,
Extents &&image_extents, bufferlist &&bl,
- int op_flags,
+ IOContext io_context, int op_flags,
const ZTracer::Trace &parent_trace) {
ImageWriteRequest<I> req(*ictx, c, std::move(image_extents), std::move(bl),
- op_flags, parent_trace);
+ io_context, op_flags, parent_trace);
req.send();
}
void ImageRequest<I>::aio_discard(I *ictx, AioCompletion *c,
Extents &&image_extents,
uint32_t discard_granularity_bytes,
- const ZTracer::Trace &parent_trace) {
+ IOContext io_context,
+ const ZTracer::Trace &parent_trace) {
ImageDiscardRequest<I> req(*ictx, c, std::move(image_extents),
- discard_granularity_bytes, parent_trace);
+ discard_granularity_bytes, io_context,
+ parent_trace);
req.send();
}
template <typename I>
void ImageRequest<I>::aio_writesame(I *ictx, AioCompletion *c,
Extents &&image_extents,
- bufferlist &&bl, int op_flags,
+ bufferlist &&bl, IOContext io_context,
+ int op_flags,
const ZTracer::Trace &parent_trace) {
ImageWriteSameRequest<I> req(*ictx, c, std::move(image_extents),
- std::move(bl), op_flags, parent_trace);
+ std::move(bl), io_context, op_flags,
+ parent_trace);
req.send();
}
bufferlist &&cmp_bl,
bufferlist &&bl,
uint64_t *mismatch_offset,
- int op_flags,
+ IOContext io_context, int op_flags,
const ZTracer::Trace &parent_trace) {
ImageCompareAndWriteRequest<I> req(*ictx, c, std::move(image_extents),
std::move(cmp_bl), std::move(bl),
- mismatch_offset, op_flags, parent_trace);
+ mismatch_offset, io_context, op_flags,
+ parent_trace);
req.send();
}
template <typename I>
ImageReadRequest<I>::ImageReadRequest(I &image_ctx, AioCompletion *aio_comp,
Extents &&image_extents,
- ReadResult &&read_result, int op_flags,
+ ReadResult &&read_result,
+ IOContext io_context, int op_flags,
const ZTracer::Trace &parent_trace)
- : ImageRequest<I>(image_ctx, aio_comp, std::move(image_extents), "read",
- parent_trace),
+ : ImageRequest<I>(image_ctx, aio_comp, std::move(image_extents),
+ io_context, "read", parent_trace),
m_op_flags(op_flags) {
aio_comp->read_result = std::move(read_result);
}
auto &image_extents = this->m_image_extents;
if (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);
+ readahead(get_image_ctx(&image_ctx), image_extents, this->m_io_context);
}
// map image extents to object extents
buffer_ofs += extent.second;
}
- auto io_context = image_ctx.get_data_io_context();
-
// issue the requests
AioCompletion *aio_comp = this->m_aio_comp;
aio_comp->set_request_count(object_extents.size());
aio_comp, oe.offset, oe.length, std::move(oe.buffer_extents));
auto req = ObjectDispatchSpec::create_read(
&image_ctx, OBJECT_DISPATCH_LAYER_NONE, oe.object_no,
- {{oe.offset, oe.length}}, io_context, m_op_flags, this->m_trace,
+ {{oe.offset, oe.length}}, this->m_io_context, m_op_flags, this->m_trace,
&req_comp->bl, &req_comp->extent_map, nullptr, req_comp);
req->send();
}
AioCompletion *aio_comp = this->m_aio_comp;
{
std::shared_lock image_locker{this->m_image_ctx.image_lock};
- if (this->m_image_ctx.snap_id != CEPH_NOSNAP || this->m_image_ctx.read_only) {
+ if (this->m_image_ctx.snap_id != CEPH_NOSNAP ||
+ this->m_image_ctx.read_only) {
aio_comp->fail(-EROFS);
return true;
}
bool journaling = false;
- auto io_context = image_ctx.get_data_io_context();
AioCompletion *aio_comp = this->m_aio_comp;
{
// prevent image size from changing between computing clip and recording
journal_tid = append_journal_event(m_synchronous);
}
- send_object_requests(object_extents, io_context, journal_tid);
+ send_object_requests(object_extents, this->m_io_context, journal_tid);
}
update_stats(clip_len);
static void aio_read(ImageCtxT *ictx, AioCompletion *c,
Extents &&image_extents, ReadResult &&read_result,
- int op_flags, const ZTracer::Trace &parent_trace);
+ IOContext io_context, int op_flags,
+ const ZTracer::Trace &parent_trace);
static void aio_write(ImageCtxT *ictx, AioCompletion *c,
- Extents &&image_extents, bufferlist &&bl, int op_flags,
+ Extents &&image_extents, bufferlist &&bl,
+ IOContext io_context, int op_flags,
const ZTracer::Trace &parent_trace);
static void aio_discard(ImageCtxT *ictx, AioCompletion *c,
Extents &&image_extents,
uint32_t discard_granularity_bytes,
+ IOContext io_context,
const ZTracer::Trace &parent_trace);
static void aio_flush(ImageCtxT *ictx, AioCompletion *c,
FlushSource flush_source,
const ZTracer::Trace &parent_trace);
static void aio_writesame(ImageCtxT *ictx, AioCompletion *c,
Extents &&image_extents, bufferlist &&bl,
- int op_flags, const ZTracer::Trace &parent_trace);
+ IOContext io_context, int op_flags,
+ const ZTracer::Trace &parent_trace);
static void aio_compare_and_write(ImageCtxT *ictx, AioCompletion *c,
- Extents &&image_extents, bufferlist &&cmp_bl,
+ Extents &&image_extents,
+ bufferlist &&cmp_bl,
bufferlist &&bl, uint64_t *mismatch_offset,
- int op_flags, const ZTracer::Trace &parent_trace);
+ IOContext io_context, int op_flags,
+ const ZTracer::Trace &parent_trace);
void send();
ImageCtxT &m_image_ctx;
AioCompletion *m_aio_comp;
Extents m_image_extents;
+ IOContext m_io_context;
ZTracer::Trace m_trace;
bool m_bypass_image_cache = false;
ImageRequest(ImageCtxT &image_ctx, AioCompletion *aio_comp,
- Extents &&image_extents, const char *trace_name,
+ Extents &&image_extents, 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_image_extents(std::move(image_extents)), m_io_context(io_context),
m_trace(librbd::util::create_trace(image_ctx, trace_name, parent_trace)) {
m_trace.event("start");
}
ImageReadRequest(ImageCtxT &image_ctx, AioCompletion *aio_comp,
Extents &&image_extents, ReadResult &&read_result,
- int op_flags, const ZTracer::Trace &parent_trace);
+ IOContext io_context, int op_flags,
+ const ZTracer::Trace &parent_trace);
protected:
int clip_request() override;
using typename ImageRequest<ImageCtxT>::Extents;
AbstractImageWriteRequest(ImageCtxT &image_ctx, AioCompletion *aio_comp,
- Extents &&image_extents, const char *trace_name,
+ Extents &&image_extents, IOContext io_context,
+ const char *trace_name,
const ZTracer::Trace &parent_trace)
: ImageRequest<ImageCtxT>(image_ctx, aio_comp, std::move(image_extents),
- trace_name, parent_trace),
+ io_context, trace_name, parent_trace),
m_synchronous(false) {
}
using typename ImageRequest<ImageCtxT>::Extents;
ImageWriteRequest(ImageCtxT &image_ctx, AioCompletion *aio_comp,
- Extents &&image_extents, bufferlist &&bl, int op_flags,
+ Extents &&image_extents, bufferlist &&bl,
+ IOContext io_context, int op_flags,
const ZTracer::Trace &parent_trace)
: AbstractImageWriteRequest<ImageCtxT>(
- image_ctx, aio_comp, std::move(image_extents), "write", parent_trace),
+ image_ctx, aio_comp, std::move(image_extents), io_context, "write",
+ parent_trace),
m_bl(std::move(bl)), m_op_flags(op_flags) {
}
public:
ImageDiscardRequest(ImageCtxT &image_ctx, AioCompletion *aio_comp,
Extents&& image_extents,
- uint32_t discard_granularity_bytes,
+ uint32_t discard_granularity_bytes, IOContext io_context,
const ZTracer::Trace &parent_trace)
: AbstractImageWriteRequest<ImageCtxT>(
- image_ctx, aio_comp, std::move(image_extents), "discard", parent_trace),
+ image_ctx, aio_comp, std::move(image_extents), io_context, "discard",
+ parent_trace),
m_discard_granularity_bytes(discard_granularity_bytes) {
}
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, {}, {}, "flush",
+ parent_trace),
m_flush_source(flush_source) {
}
public:
ImageWriteSameRequest(ImageCtxT &image_ctx, AioCompletion *aio_comp,
Extents&& image_extents, bufferlist &&bl,
- int op_flags, const ZTracer::Trace &parent_trace)
+ IOContext io_context, int op_flags,
+ const ZTracer::Trace &parent_trace)
: AbstractImageWriteRequest<ImageCtxT>(
- image_ctx, aio_comp, std::move(image_extents), "writesame",
+ image_ctx, aio_comp, std::move(image_extents), io_context, "writesame",
parent_trace),
m_data_bl(std::move(bl)), m_op_flags(op_flags) {
}
ImageCompareAndWriteRequest(ImageCtxT &image_ctx, AioCompletion *aio_comp,
Extents &&image_extents, bufferlist &&cmp_bl,
bufferlist &&bl, uint64_t *mismatch_offset,
- int op_flags, const ZTracer::Trace &parent_trace)
+ IOContext io_context, int op_flags,
+ const ZTracer::Trace &parent_trace)
: AbstractImageWriteRequest<ImageCtxT>(
- image_ctx, aio_comp, std::move(image_extents), "compare_and_write", parent_trace),
+ image_ctx, aio_comp, std::move(image_extents), 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) {
}
template <typename I>
bool QosImageDispatch<I>::read(
AioCompletion* aio_comp, Extents &&image_extents, ReadResult &&read_result,
- int op_flags, const ZTracer::Trace &parent_trace, uint64_t tid,
- std::atomic<uint32_t>* image_dispatch_flags,
+ IOContext io_context, int op_flags, const ZTracer::Trace &parent_trace,
+ uint64_t tid, std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) {
auto cct = m_image_ctx->cct;
template <typename I>
bool QosImageDispatch<I>::write(
AioCompletion* aio_comp, Extents &&image_extents, bufferlist &&bl,
- int op_flags, const ZTracer::Trace &parent_trace, uint64_t tid,
- std::atomic<uint32_t>* image_dispatch_flags,
+ IOContext io_context, int op_flags, const ZTracer::Trace &parent_trace,
+ uint64_t tid, std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) {
auto cct = m_image_ctx->cct;
template <typename I>
bool QosImageDispatch<I>::discard(
AioCompletion* aio_comp, Extents &&image_extents,
- uint32_t discard_granularity_bytes, const ZTracer::Trace &parent_trace,
- uint64_t tid, std::atomic<uint32_t>* image_dispatch_flags,
+ uint32_t discard_granularity_bytes, IOContext io_context,
+ const ZTracer::Trace &parent_trace, uint64_t tid,
+ std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) {
auto cct = m_image_ctx->cct;
template <typename I>
bool QosImageDispatch<I>::write_same(
AioCompletion* aio_comp, Extents &&image_extents, bufferlist &&bl,
- int op_flags, const ZTracer::Trace &parent_trace, uint64_t tid,
- std::atomic<uint32_t>* image_dispatch_flags,
+ IOContext io_context, int op_flags, const ZTracer::Trace &parent_trace,
+ uint64_t tid, std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) {
auto cct = m_image_ctx->cct;
template <typename I>
bool QosImageDispatch<I>::compare_and_write(
AioCompletion* aio_comp, Extents &&image_extents, bufferlist &&cmp_bl,
- bufferlist &&bl, uint64_t *mismatch_offset, int op_flags,
- const ZTracer::Trace &parent_trace, uint64_t tid,
+ bufferlist &&bl, uint64_t *mismatch_offset, IOContext io_context,
+ int op_flags, const ZTracer::Trace &parent_trace, uint64_t tid,
std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) {
bool read(
AioCompletion* aio_comp, Extents &&image_extents,
- ReadResult &&read_result, int op_flags,
+ ReadResult &&read_result, IOContext io_context, int op_flags,
const ZTracer::Trace &parent_trace, uint64_t tid,
std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) override;
bool write(
AioCompletion* aio_comp, Extents &&image_extents, bufferlist &&bl,
- int op_flags, const ZTracer::Trace &parent_trace, uint64_t tid,
- std::atomic<uint32_t>* image_dispatch_flags,
+ IOContext io_context, int op_flags, const ZTracer::Trace &parent_trace,
+ uint64_t tid, std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) override;
bool discard(
AioCompletion* aio_comp, Extents &&image_extents,
- uint32_t discard_granularity_bytes,
+ uint32_t discard_granularity_bytes, IOContext io_context,
const ZTracer::Trace &parent_trace, uint64_t tid,
std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) override;
bool write_same(
AioCompletion* aio_comp, Extents &&image_extents, bufferlist &&bl,
- int op_flags, const ZTracer::Trace &parent_trace, uint64_t tid,
- std::atomic<uint32_t>* image_dispatch_flags,
+ IOContext io_context, int op_flags, const ZTracer::Trace &parent_trace,
+ uint64_t tid, std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) override;
bool compare_and_write(
AioCompletion* aio_comp, Extents &&image_extents, bufferlist &&cmp_bl,
- bufferlist &&bl, uint64_t *mismatch_offset, int op_flags,
- const ZTracer::Trace &parent_trace, uint64_t tid,
+ bufferlist &&bl, uint64_t *mismatch_offset, IOContext io_context,
+ int op_flags, const ZTracer::Trace &parent_trace, uint64_t tid,
std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) override;
template <typename I>
bool QueueImageDispatch<I>::read(
AioCompletion* aio_comp, Extents &&image_extents, ReadResult &&read_result,
- int op_flags, const ZTracer::Trace &parent_trace, uint64_t tid,
- std::atomic<uint32_t>* image_dispatch_flags,
+ IOContext io_context, int op_flags, const ZTracer::Trace &parent_trace,
+ uint64_t tid, std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) {
auto cct = m_image_ctx->cct;
template <typename I>
bool QueueImageDispatch<I>::write(
AioCompletion* aio_comp, Extents &&image_extents, bufferlist &&bl,
- int op_flags, const ZTracer::Trace &parent_trace, uint64_t tid,
- std::atomic<uint32_t>* image_dispatch_flags,
+ IOContext io_context, int op_flags, const ZTracer::Trace &parent_trace,
+ uint64_t tid, std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) {
auto cct = m_image_ctx->cct;
template <typename I>
bool QueueImageDispatch<I>::discard(
AioCompletion* aio_comp, Extents &&image_extents,
- uint32_t discard_granularity_bytes, const ZTracer::Trace &parent_trace,
+ uint32_t discard_granularity_bytes, IOContext io_context,
+ const ZTracer::Trace &parent_trace,
uint64_t tid, std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) {
template <typename I>
bool QueueImageDispatch<I>::write_same(
AioCompletion* aio_comp, Extents &&image_extents, bufferlist &&bl,
- int op_flags, const ZTracer::Trace &parent_trace, uint64_t tid,
- std::atomic<uint32_t>* image_dispatch_flags,
+ IOContext io_context, int op_flags, const ZTracer::Trace &parent_trace,
+ uint64_t tid, std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) {
auto cct = m_image_ctx->cct;
template <typename I>
bool QueueImageDispatch<I>::compare_and_write(
AioCompletion* aio_comp, Extents &&image_extents, bufferlist &&cmp_bl,
- bufferlist &&bl, uint64_t *mismatch_offset, int op_flags,
- const ZTracer::Trace &parent_trace, uint64_t tid,
+ bufferlist &&bl, uint64_t *mismatch_offset, IOContext io_context,
+ int op_flags, const ZTracer::Trace &parent_trace, uint64_t tid,
std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) {
bool read(
AioCompletion* aio_comp, Extents &&image_extents,
- ReadResult &&read_result, int op_flags,
+ ReadResult &&read_result, IOContext io_context, int op_flags,
const ZTracer::Trace &parent_trace, uint64_t tid,
std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) override;
bool write(
AioCompletion* aio_comp, Extents &&image_extents, bufferlist &&bl,
- int op_flags, const ZTracer::Trace &parent_trace, uint64_t tid,
- std::atomic<uint32_t>* image_dispatch_flags,
+ IOContext io_context, int op_flags, const ZTracer::Trace &parent_trace,
+ uint64_t tid, std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) override;
bool discard(
AioCompletion* aio_comp, Extents &&image_extents,
- uint32_t discard_granularity_bytes,
+ uint32_t discard_granularity_bytes, IOContext io_context,
const ZTracer::Trace &parent_trace, uint64_t tid,
std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) override;
bool write_same(
AioCompletion* aio_comp, Extents &&image_extents, bufferlist &&bl,
- int op_flags, const ZTracer::Trace &parent_trace, uint64_t tid,
- std::atomic<uint32_t>* image_dispatch_flags,
+ IOContext io_context, int op_flags, const ZTracer::Trace &parent_trace,
+ uint64_t tid, std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) override;
bool compare_and_write(
AioCompletion* aio_comp, Extents &&image_extents, bufferlist &&cmp_bl,
- bufferlist &&bl, uint64_t *mismatch_offset, int op_flags,
- const ZTracer::Trace &parent_trace, uint64_t tid,
+ bufferlist &&bl, uint64_t *mismatch_offset, IOContext io_context,
+ int op_flags, const ZTracer::Trace &parent_trace, uint64_t tid,
std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) override;
template <typename I>
bool RefreshImageDispatch<I>::read(
AioCompletion* aio_comp, Extents &&image_extents, ReadResult &&read_result,
- int op_flags, const ZTracer::Trace &parent_trace, uint64_t tid,
- std::atomic<uint32_t>* image_dispatch_flags,
+ IOContext io_context, int op_flags, const ZTracer::Trace &parent_trace,
+ uint64_t tid, std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) {
auto cct = m_image_ctx->cct;
template <typename I>
bool RefreshImageDispatch<I>::write(
AioCompletion* aio_comp, Extents &&image_extents, bufferlist &&bl,
- int op_flags, const ZTracer::Trace &parent_trace, uint64_t tid,
- std::atomic<uint32_t>* image_dispatch_flags,
+ IOContext io_context, int op_flags, const ZTracer::Trace &parent_trace,
+ uint64_t tid, std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) {
auto cct = m_image_ctx->cct;
template <typename I>
bool RefreshImageDispatch<I>::discard(
AioCompletion* aio_comp, Extents &&image_extents,
- uint32_t discard_granularity_bytes, const ZTracer::Trace &parent_trace,
- uint64_t tid, std::atomic<uint32_t>* image_dispatch_flags,
+ uint32_t discard_granularity_bytes, IOContext io_context,
+ const ZTracer::Trace &parent_trace, uint64_t tid,
+ std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) {
auto cct = m_image_ctx->cct;
template <typename I>
bool RefreshImageDispatch<I>::write_same(
AioCompletion* aio_comp, Extents &&image_extents, bufferlist &&bl,
- int op_flags, const ZTracer::Trace &parent_trace, uint64_t tid,
- std::atomic<uint32_t>* image_dispatch_flags,
+ IOContext io_context, int op_flags, const ZTracer::Trace &parent_trace,
+ uint64_t tid, std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) {
auto cct = m_image_ctx->cct;
template <typename I>
bool RefreshImageDispatch<I>::compare_and_write(
AioCompletion* aio_comp, Extents &&image_extents, bufferlist &&cmp_bl,
- bufferlist &&bl, uint64_t *mismatch_offset, int op_flags,
- const ZTracer::Trace &parent_trace, uint64_t tid,
+ bufferlist &&bl, uint64_t *mismatch_offset, IOContext io_context,
+ int op_flags, const ZTracer::Trace &parent_trace, uint64_t tid,
std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) {
bool read(
AioCompletion* aio_comp, Extents &&image_extents,
- ReadResult &&read_result, int op_flags,
+ ReadResult &&read_result, IOContext io_context, int op_flags,
const ZTracer::Trace &parent_trace, uint64_t tid,
std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) override;
bool write(
AioCompletion* aio_comp, Extents &&image_extents, bufferlist &&bl,
- int op_flags, const ZTracer::Trace &parent_trace, uint64_t tid,
- std::atomic<uint32_t>* image_dispatch_flags,
+ IOContext io_context, int op_flags, const ZTracer::Trace &parent_trace,
+ uint64_t tid, std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) override;
bool discard(
AioCompletion* aio_comp, Extents &&image_extents,
- uint32_t discard_granularity_bytes,
+ uint32_t discard_granularity_bytes, IOContext io_context,
const ZTracer::Trace &parent_trace, uint64_t tid,
std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) override;
bool write_same(
AioCompletion* aio_comp, Extents &&image_extents, bufferlist &&bl,
- int op_flags, const ZTracer::Trace &parent_trace, uint64_t tid,
- std::atomic<uint32_t>* image_dispatch_flags,
+ IOContext io_context, int op_flags, const ZTracer::Trace &parent_trace,
+ uint64_t tid, std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) override;
bool compare_and_write(
AioCompletion* aio_comp, Extents &&image_extents, bufferlist &&cmp_bl,
- bufferlist &&bl, uint64_t *mismatch_offset, int op_flags,
- const ZTracer::Trace &parent_trace, uint64_t tid,
+ bufferlist &&bl, uint64_t *mismatch_offset, IOContext io_context,
+ int op_flags, const ZTracer::Trace &parent_trace, uint64_t tid,
std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) override;
ldout(cct, 20) << "completion " << comp << ", extents " << parent_extents
<< dendl;
- ImageRequest<I>::aio_read(image_ctx->parent, comp, std::move(parent_extents),
- ReadResult{data}, 0, trace);
+ ImageRequest<I>::aio_read(
+ image_ctx->parent, comp, std::move(parent_extents), ReadResult{data},
+ image_ctx->parent->get_data_io_context(), 0, trace);
}
} // namespace util
template <typename I>
bool WriteBlockImageDispatch<I>::write(
AioCompletion* aio_comp, Extents &&image_extents, bufferlist &&bl,
- int op_flags, const ZTracer::Trace &parent_trace, uint64_t tid,
- std::atomic<uint32_t>* image_dispatch_flags,
+ IOContext io_context, int op_flags, const ZTracer::Trace &parent_trace,
+ uint64_t tid, std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) {
auto cct = m_image_ctx->cct;
template <typename I>
bool WriteBlockImageDispatch<I>::discard(
AioCompletion* aio_comp, Extents &&image_extents,
- uint32_t discard_granularity_bytes, const ZTracer::Trace &parent_trace,
- uint64_t tid, std::atomic<uint32_t>* image_dispatch_flags,
+ uint32_t discard_granularity_bytes, IOContext io_context,
+ const ZTracer::Trace &parent_trace, uint64_t tid,
+ std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) {
auto cct = m_image_ctx->cct;
template <typename I>
bool WriteBlockImageDispatch<I>::write_same(
AioCompletion* aio_comp, Extents &&image_extents, bufferlist &&bl,
- int op_flags, const ZTracer::Trace &parent_trace, uint64_t tid,
- std::atomic<uint32_t>* image_dispatch_flags,
+ IOContext io_context, int op_flags, const ZTracer::Trace &parent_trace,
+ uint64_t tid, std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) {
auto cct = m_image_ctx->cct;
template <typename I>
bool WriteBlockImageDispatch<I>::compare_and_write(
AioCompletion* aio_comp, Extents &&image_extents, bufferlist &&cmp_bl,
- bufferlist &&bl, uint64_t *mismatch_offset, int op_flags,
- const ZTracer::Trace &parent_trace, uint64_t tid,
+ bufferlist &&bl, uint64_t *mismatch_offset, IOContext io_context,
+ int op_flags, const ZTracer::Trace &parent_trace, uint64_t tid,
std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) {
bool read(
AioCompletion* aio_comp, Extents &&image_extents,
- ReadResult &&read_result, int op_flags,
+ ReadResult &&read_result, IOContext io_context, int op_flags,
const ZTracer::Trace &parent_trace, uint64_t tid,
std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
}
bool write(
AioCompletion* aio_comp, Extents &&image_extents, bufferlist &&bl,
- int op_flags, const ZTracer::Trace &parent_trace, uint64_t tid,
- std::atomic<uint32_t>* image_dispatch_flags,
+ IOContext io_context, int op_flags, const ZTracer::Trace &parent_trace,
+ uint64_t tid, std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) override;
bool discard(
AioCompletion* aio_comp, Extents &&image_extents,
- uint32_t discard_granularity_bytes,
+ uint32_t discard_granularity_bytes, IOContext io_context,
const ZTracer::Trace &parent_trace, uint64_t tid,
std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) override;
bool write_same(
AioCompletion* aio_comp, Extents &&image_extents, bufferlist &&bl,
- int op_flags, const ZTracer::Trace &parent_trace, uint64_t tid,
- std::atomic<uint32_t>* image_dispatch_flags,
+ IOContext io_context, int op_flags, const ZTracer::Trace &parent_trace,
+ uint64_t tid, std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) override;
bool compare_and_write(
AioCompletion* aio_comp, Extents &&image_extents, bufferlist &&cmp_bl,
- bufferlist &&bl, uint64_t *mismatch_offset, int op_flags,
- const ZTracer::Trace &parent_trace, uint64_t tid,
+ bufferlist &&bl, uint64_t *mismatch_offset, IOContext io_context,
+ int op_flags, const ZTracer::Trace &parent_trace, uint64_t tid,
std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) override;
if (!clipped_io(event.offset, aio_comp)) {
io::ImageRequest<I>::aio_discard(&m_image_ctx, aio_comp,
{{event.offset, event.length}},
- event.discard_granularity_bytes, {});
+ event.discard_granularity_bytes,
+ m_image_ctx.get_data_io_context(), {});
}
if (flush_required) {
if (!clipped_io(event.offset, aio_comp)) {
io::ImageRequest<I>::aio_write(&m_image_ctx, aio_comp,
{{event.offset, event.length}},
- std::move(data), 0, {});
+ std::move(data),
+ m_image_ctx.get_data_io_context(), 0, {});
}
if (flush_required) {
if (!clipped_io(event.offset, aio_comp)) {
io::ImageRequest<I>::aio_writesame(&m_image_ctx, aio_comp,
{{event.offset, event.length}},
- std::move(data), 0, {});
+ std::move(data),
+ m_image_ctx.get_data_io_context(), 0,
+ {});
}
if (flush_required) {
{{event.offset, event.length}},
std::move(cmp_data),
std::move(write_data),
- nullptr, 0, {});
+ nullptr,
+ m_image_ctx.get_data_io_context(),
+ 0, {});
}
if (flush_required) {
std::shared_lock owner_locker{image_ctx.owner_lock};
std::unique_lock image_locker{image_ctx.image_lock};
- if (image_ctx.old_format) {
- return;
- }
-
if (image_ctx.get_snap_info(m_snap_id) != NULL) {
return;
}
static void aio_read(MockTestImageCtx *ictx, AioCompletion *c,
Extents &&image_extents, ReadResult &&read_result,
- int op_flags, const ZTracer::Trace &parent_trace) {
+ IOContext io_context, int op_flags,
+ const ZTracer::Trace &parent_trace) {
ceph_assert(s_instance != nullptr);
s_instance->aio_read(c, image_extents);
}
static ImageRequest *s_instance;
static void aio_read(librbd::MockImageCtx *ictx, AioCompletion *c,
Extents &&image_extents, ReadResult &&read_result,
- int op_flags, const ZTracer::Trace &parent_trace) {
+ IOContext io_context, int op_flags,
+ const ZTracer::Trace &parent_trace) {
s_instance->aio_read(c, image_extents, &read_result);
}
bufferlist bl;
bl.append("1");
- MockImageWriteRequest mock_aio_image_write_1(mock_image_ctx, aio_comp_1,
- {{0, 1}}, std::move(bl), 0, {});
+ MockImageWriteRequest mock_aio_image_write_1(
+ mock_image_ctx, aio_comp_1, {{0, 1}}, std::move(bl),
+ mock_image_ctx.get_data_io_context(), 0, {});
{
std::shared_lock owner_locker{mock_image_ctx.owner_lock};
mock_aio_image_write_1.send();
expect_object_request_send(mock_image_ctx, 0);
bl.append("1");
- MockImageWriteRequest mock_aio_image_write_2(mock_image_ctx, aio_comp_2,
- {{0, 1}}, std::move(bl), 0, {});
+ MockImageWriteRequest mock_aio_image_write_2(
+ mock_image_ctx, aio_comp_2, {{0, 1}}, std::move(bl),
+ mock_image_ctx.get_data_io_context(), 0, {});
{
std::shared_lock owner_locker{mock_image_ctx.owner_lock};
mock_aio_image_write_2.send();
&aio_comp_ctx_2, ictx, AIO_TYPE_WRITE);
bufferlist bl;
- MockImageWriteRequest mock_aio_image_write_1(mock_image_ctx, aio_comp_1,
- {{0, 0}}, std::move(bl), 0, {});
+ MockImageWriteRequest mock_aio_image_write_1(
+ mock_image_ctx, aio_comp_1, {{0, 0}}, std::move(bl),
+ mock_image_ctx.get_data_io_context(), 0, {});
{
std::shared_lock owner_locker{mock_image_ctx.owner_lock};
mock_aio_image_write_1.send();
mock_image_ctx.snap_id = 123;
bl.append("1");
- MockImageWriteRequest mock_aio_image_write_2(mock_image_ctx, aio_comp_2,
- {{0, 1}}, std::move(bl), 0, {});
+ MockImageWriteRequest mock_aio_image_write_2(
+ mock_image_ctx, aio_comp_2, {{0, 1}}, std::move(bl),
+ mock_image_ctx.get_data_io_context(), 0, {});
{
std::shared_lock owner_locker{mock_image_ctx.owner_lock};
mock_aio_image_write_2.send();
ReadResult rr;
- MockImageReadRequest mock_aio_image_read_1(mock_image_ctx, aio_comp_1,
- {{0, 1}}, std::move(rr), 0, {});
+ MockImageReadRequest mock_aio_image_read_1(
+ mock_image_ctx, aio_comp_1, {{0, 1}}, std::move(rr),
+ mock_image_ctx.get_data_io_context(), 0, {});
{
std::shared_lock owner_locker{mock_image_ctx.owner_lock};
mock_aio_image_read_1.send();
&aio_comp_ctx_2, ictx, AIO_TYPE_READ);
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), 0, {});
+ MockImageReadRequest mock_aio_image_read_2(
+ mock_image_ctx, aio_comp_2, {{0, 1}}, std::move(rr),
+ mock_image_ctx.get_data_io_context(), 0, {});
{
std::shared_lock owner_locker{mock_image_ctx.owner_lock};
mock_aio_image_read_2.send();
&aio_comp_ctx, ictx, AIO_TYPE_DISCARD);
MockImageDiscardRequest mock_aio_image_discard(
mock_image_ctx, aio_comp, {{16, 63}, {84, 100}},
- ictx->discard_granularity_bytes, {});
+ 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();
MockImageDiscardRequest mock_aio_image_discard(
mock_image_ctx, aio_comp,
{{ictx->layout.object_size - 1024, 1024}},
- ictx->discard_granularity_bytes, {});
+ 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();
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, {});
+ 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();
bufferlist bl;
bl.append("1");
- MockImageWriteRequest mock_aio_image_write(mock_image_ctx, aio_comp,
- {{0, 1}}, std::move(bl), 0, {});
+ MockImageWriteRequest mock_aio_image_write(
+ mock_image_ctx, aio_comp, {{0, 1}}, std::move(bl),
+ mock_image_ctx.get_data_io_context(), 0, {});
{
std::shared_lock owner_locker{mock_image_ctx.owner_lock};
mock_aio_image_write.send();
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, aio_comp, {{0, 1}}, 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();
bufferlist bl;
bl.append("1");
- MockImageWriteSameRequest mock_aio_image_writesame(mock_image_ctx, aio_comp,
- {{0, 1}}, std::move(bl), 0,
- {});
+ MockImageWriteSameRequest mock_aio_image_writesame(
+ mock_image_ctx, aio_comp, {{0, 1}}, std::move(bl),
+ mock_image_ctx.get_data_io_context(), 0, {});
{
std::shared_lock owner_locker{mock_image_ctx.owner_lock};
mock_aio_image_writesame.send();
bufferlist write_bl;
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,
- 0, {});
+ 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, {});
{
std::shared_lock owner_locker{mock_image_ctx.owner_lock};
mock_aio_image_write.send();
const bufferlist &bl, int op_flags));
static void aio_write(MockReplayImageCtx *ictx, AioCompletion *c,
Extents &&image_extents, bufferlist &&bl,
- int op_flags, const ZTracer::Trace &parent_trace) {
+ 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);
}
static void aio_discard(MockReplayImageCtx *ictx, AioCompletion *c,
Extents&& image_extents,
uint32_t discard_granularity_bytes,
+ IOContext io_context,
const ZTracer::Trace &parent_trace) {
ceph_assert(s_instance != nullptr);
s_instance->aio_discard(c, image_extents, discard_granularity_bytes);
MOCK_METHOD4(aio_writesame, void(AioCompletion *c,
const Extents& image_extents,
- const bufferlist &bl, int op_flags));
+ const bufferlist &bl,
+ int op_flags));
static void aio_writesame(MockReplayImageCtx *ictx, AioCompletion *c,
Extents&& image_extents, bufferlist &&bl,
- int op_flags, const ZTracer::Trace &parent_trace) {
+ 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);
}
MOCK_METHOD6(aio_compare_and_write, void(AioCompletion *c, const Extents &image_extents,
const bufferlist &cmp_bl, const bufferlist &bl,
- uint64_t *mismatch_offset, int op_flags));
+ 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,
- int op_flags, const ZTracer::Trace &parent_trace) {
+ IOContext io_context, int op_flags,
+ const ZTracer::Trace &parent_trace) {
ceph_assert(s_instance != nullptr);
s_instance->aio_compare_and_write(c, image_extents, cmp_bl, bl,
mismatch_offset, op_flags);
bool read(
AioCompletion* aio_comp, Extents &&image_extents,
- ReadResult &&read_result, int op_flags,
+ ReadResult &&read_result, IOContext io_context, int op_flags,
const ZTracer::Trace &parent_trace, uint64_t tid,
std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
bool write(
AioCompletion* aio_comp, Extents &&image_extents, bufferlist &&bl,
- int op_flags, const ZTracer::Trace &parent_trace, uint64_t tid,
- std::atomic<uint32_t>* image_dispatch_flags,
+ IOContext io_context, int op_flags, const ZTracer::Trace &parent_trace,
+ uint64_t tid, std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) override {
return false;
bool discard(
AioCompletion* aio_comp, Extents &&image_extents,
- uint32_t discard_granularity_bytes,
+ uint32_t discard_granularity_bytes, IOContext io_context,
const ZTracer::Trace &parent_trace, uint64_t tid,
std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
bool write_same(
AioCompletion* aio_comp, Extents &&image_extents, bufferlist &&bl,
- int op_flags, const ZTracer::Trace &parent_trace, uint64_t tid,
- std::atomic<uint32_t>* image_dispatch_flags,
+ IOContext io_context, int op_flags, const ZTracer::Trace &parent_trace,
+ uint64_t tid, std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) override {
return false;
bool compare_and_write(
AioCompletion* aio_comp, Extents &&image_extents, bufferlist &&cmp_bl,
- bufferlist &&bl, uint64_t *mismatch_offset, int op_flags,
- const ZTracer::Trace &parent_trace, uint64_t tid,
+ bufferlist &&bl, uint64_t *mismatch_offset, IOContext io_context,
+ int op_flags, const ZTracer::Trace &parent_trace, uint64_t tid,
std::atomic<uint32_t>* image_dispatch_flags,
DispatchResult* dispatch_result, Context** on_finish,
Context* on_dispatched) override {
expect_block_writes(mock_image_ctx);
expect_allocate_snap_id(mock_image_ctx, 0);
expect_snap_create(mock_image_ctx, 0);
- if (!mock_image_ctx.old_format) {
- expect_object_map_snap_create(mock_image_ctx);
- expect_update_snap_context(mock_image_ctx);
- EXPECT_CALL(mock_image_ctx, rebuild_data_io_context());
- }
+ expect_object_map_snap_create(mock_image_ctx);
+ expect_update_snap_context(mock_image_ctx);
+ EXPECT_CALL(mock_image_ctx, rebuild_data_io_context());
expect_unblock_writes(mock_image_ctx);
expect_notify_unquiesce(mock_image_ctx, -EINVAL);
expect_block_writes(mock_image_ctx);
expect_allocate_snap_id(mock_image_ctx, -ESTALE);
expect_snap_create(mock_image_ctx, -ESTALE);
- if (!mock_image_ctx.old_format) {
- expect_object_map_snap_create(mock_image_ctx);
- expect_update_snap_context(mock_image_ctx);
- EXPECT_CALL(mock_image_ctx, rebuild_data_io_context());
- }
+ expect_object_map_snap_create(mock_image_ctx);
+ expect_update_snap_context(mock_image_ctx);
+ EXPECT_CALL(mock_image_ctx, rebuild_data_io_context());
expect_unblock_writes(mock_image_ctx);
expect_notify_unquiesce(mock_image_ctx, 0);
expect_block_writes(mock_image_ctx);
expect_allocate_snap_id(mock_image_ctx, 0);
expect_snap_create(mock_image_ctx, 0);
- if (!mock_image_ctx.old_format) {
- expect_object_map_snap_create(mock_image_ctx);
- expect_update_snap_context(mock_image_ctx);
- EXPECT_CALL(mock_image_ctx, rebuild_data_io_context());
- }
+ expect_object_map_snap_create(mock_image_ctx);
+ expect_update_snap_context(mock_image_ctx);
+ EXPECT_CALL(mock_image_ctx, rebuild_data_io_context());
expect_unblock_writes(mock_image_ctx);
C_SaferCond cond_ctx;
projects / ceph.git / commitdiff