${rbd_plugin_parent_cache_srcs})
target_link_libraries(librbd_plugin_parent_cache PRIVATE
ceph_immutable_object_cache_lib ceph-common librbd
+ libneorados
librados)
set_target_properties(librbd_plugin_parent_cache PROPERTIES
OUTPUT_NAME ceph_librbd_parent_cache
void ImageCtx::rebuild_data_io_context() {
auto ctx = std::make_shared<neorados::IOContext>(
data_ctx.get_id(), data_ctx.get_namespace());
- ctx->read_snap(snap_id);
- ctx->write_snap_context(
- {{snapc.seq, {snapc.snaps.begin(), snapc.snaps.end()}}});
+ if (snap_id != CEPH_NOSNAP) {
+ ctx->read_snap(snap_id);
+ }
+ if (!snapc.snaps.empty()) {
+ ctx->write_snap_context(
+ {{snapc.seq, {snapc.snaps.begin(), snapc.snaps.end()}}});
+ }
// atomically reset the data IOContext to new version
atomic_store(&data_io_context, ctx);
return;
}
- ::SnapContext snapc = m_image_ctx.snapc;
-
uint64_t overlap;
int r = m_image_ctx.get_parent_overlap(CEPH_NOSNAP, &overlap);
ceph_assert(r == 0);
operation::FlattenRequest<I> *req = new operation::FlattenRequest<I>(
m_image_ctx, new C_NotifyUpdate<I>(m_image_ctx, on_finish), overlap_objects,
- snapc, prog_ctx);
+ prog_ctx);
req->send();
}
#include "librbd/Utils.h"
#include "include/rbd_types.h"
#include "include/stringify.h"
+#include "include/neorados/RADOS.hpp"
#include "include/rbd/features.h"
#include "common/dout.h"
#include "librbd/ImageCtx.h"
}
}
+SnapContext get_snap_context(
+ const std::optional<
+ std::pair<std::uint64_t,
+ std::vector<std::uint64_t>>>& write_snap_context) {
+ SnapContext snapc;
+ if (write_snap_context) {
+ snapc = SnapContext{write_snap_context->first,
+ {write_snap_context->second.begin(),
+ write_snap_context->second.end()}};
+ }
+ return snapc;
+}
+
} // namespace util
} // namespace librbd
#include "include/rbd_types.h"
#include "include/ceph_assert.h"
#include "include/Context.h"
+#include "common/snap_types.h"
#include "common/zipkin_trace.h"
#include "common/RefCountedObj.h"
#include <atomic>
+#include <optional>
#include <type_traits>
+#include <utility>
+#include <vector>
#include <stdio.h>
namespace librbd {
uint32_t get_default_snap_create_flags(ImageCtx *ictx);
+SnapContext get_snap_context(
+ const std::optional<
+ std::pair<std::uint64_t,
+ std::vector<std::uint64_t>>>& write_snap_context);
+
} // namespace util
} // namespace librbd
// vim: ts=8 sw=2 smarttab
#include "librbd/cache/ObjectCacherObjectDispatch.h"
+#include "include/neorados/RADOS.hpp"
#include "common/errno.h"
#include "librbd/ImageCtx.h"
#include "librbd/Journal.h"
template <typename I>
bool ObjectCacherObjectDispatch<I>::read(
- uint64_t object_no, const io::Extents &extents, librados::snap_t snap_id,
+ uint64_t object_no, const io::Extents &extents, IOContext io_context,
int op_flags, const ZTracer::Trace &parent_trace,
ceph::bufferlist* read_data, io::Extents* extent_map, uint64_t* version,
int* object_dispatch_flags, io::DispatchResult* dispatch_result,
on_dispatched);
m_image_ctx->image_lock.lock_shared();
- auto rd = m_object_cacher->prepare_read(snap_id, read_data, op_flags);
+ auto rd = m_object_cacher->prepare_read(
+ io_context->read_snap().value_or(CEPH_NOSNAP), read_data, op_flags);
m_image_ctx->image_lock.unlock_shared();
ObjectExtent extent(data_object_name(m_image_ctx, object_no), object_no,
template <typename I>
bool ObjectCacherObjectDispatch<I>::discard(
uint64_t object_no, uint64_t object_off, uint64_t object_len,
- const ::SnapContext &snapc, int discard_flags,
+ IOContext io_context, int discard_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, io::DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) {
template <typename I>
bool ObjectCacherObjectDispatch<I>::write(
uint64_t object_no, uint64_t object_off, ceph::bufferlist&& data,
- const ::SnapContext &snapc, int op_flags, int write_flags,
+ IOContext io_context, int op_flags, int write_flags,
std::optional<uint64_t> assert_version,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, io::DispatchResult* dispatch_result,
return true;
}
+ SnapContext snapc;
+ if (io_context->write_snap_context()) {
+ auto write_snap_context = *io_context->write_snap_context();
+ snapc = std::move(SnapContext(write_snap_context.first,
+ {write_snap_context.second.begin(),
+ write_snap_context.second.end()}));
+ }
+
m_image_ctx->image_lock.lock_shared();
ObjectCacher::OSDWrite *wr = m_object_cacher->prepare_write(
snapc, data, ceph::real_time::min(), op_flags, *journal_tid);
bool ObjectCacherObjectDispatch<I>::write_same(
uint64_t object_no, uint64_t object_off, uint64_t object_len,
io::LightweightBufferExtents&& buffer_extents, ceph::bufferlist&& data,
- const ::SnapContext &snapc, int op_flags,
+ IOContext io_context, int op_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, io::DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) {
bufferlist ws_data;
io::util::assemble_write_same_extent(extent, data, &ws_data, true);
- return write(object_no, object_off, std::move(ws_data), snapc, op_flags, 0,
- std::nullopt, parent_trace, object_dispatch_flags, journal_tid,
- dispatch_result, on_finish, on_dispatched);
+ return write(object_no, object_off, std::move(ws_data), io_context, op_flags,
+ 0, std::nullopt, parent_trace, object_dispatch_flags,
+ journal_tid, dispatch_result, on_finish, on_dispatched);
}
template <typename I>
bool ObjectCacherObjectDispatch<I>::compare_and_write(
uint64_t object_no, uint64_t object_off, ceph::bufferlist&& cmp_data,
- ceph::bufferlist&& write_data, const ::SnapContext &snapc, int op_flags,
+ ceph::bufferlist&& write_data, IOContext io_context, int op_flags,
const ZTracer::Trace &parent_trace, uint64_t* mismatch_offset,
int* object_dispatch_flags, uint64_t* journal_tid,
io::DispatchResult* dispatch_result, Context** on_finish,
void shut_down(Context* on_finish) override;
bool read(
- uint64_t object_no, const io::Extents &extents, librados::snap_t snap_id,
+ uint64_t object_no, const io::Extents &extents, IOContext io_context,
int op_flags, const ZTracer::Trace &parent_trace,
ceph::bufferlist* read_data, io::Extents* extent_map,
uint64_t* version, int* object_dispatch_flags,
bool discard(
uint64_t object_no, uint64_t object_off, uint64_t object_len,
- const ::SnapContext &snapc, int discard_flags,
+ IOContext io_context, int discard_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, io::DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) override;
bool write(
uint64_t object_no, uint64_t object_off, ceph::bufferlist&& data,
- const ::SnapContext &snapc, int op_flags, int write_flags,
+ IOContext io_context, int op_flags, int write_flags,
std::optional<uint64_t> assert_version,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, io::DispatchResult* dispatch_result,
bool write_same(
uint64_t object_no, uint64_t object_off, uint64_t object_len,
io::LightweightBufferExtents&& buffer_extents, ceph::bufferlist&& data,
- const ::SnapContext &snapc, int op_flags,
+ IOContext io_context, int op_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, io::DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) override;
bool compare_and_write(
uint64_t object_no, uint64_t object_off, ceph::bufferlist&& cmp_data,
- ceph::bufferlist&& write_data, const ::SnapContext &snapc, int op_flags,
+ ceph::bufferlist&& write_data, IOContext io_context, int op_flags,
const ZTracer::Trace &parent_trace, uint64_t* mismatch_offset,
int* object_dispatch_flags, uint64_t* journal_tid,
io::DispatchResult* dispatch_result, Context** on_finish,
#include "common/ceph_mutex.h"
#include "osdc/Striper.h"
#include "include/Context.h"
+#include "include/neorados/RADOS.hpp"
#include "include/rados/librados.hpp"
#include "include/rbd/librbd.hpp"
auto req_comp = new io::ReadResult::C_ObjectReadRequest(
aio_comp, off, len, {{0, len}});
+ auto io_context = m_ictx->duplicate_data_io_context();
+ if (snapid != CEPH_NOSNAP) {
+ io_context->read_snap(snapid);
+ }
+
auto req = io::ObjectDispatchSpec::create_read(
- m_ictx, io::OBJECT_DISPATCH_LAYER_CACHE, object_no, {{off, len}}, snapid,
- op_flags, trace, &req_comp->bl, &req_comp->extent_map, nullptr, req_comp);
+ m_ictx, io::OBJECT_DISPATCH_LAYER_CACHE, object_no, {{off, len}},
+ io_context, op_flags, trace, &req_comp->bl,
+ &req_comp->extent_map, nullptr, req_comp);
req->send();
}
Context *ctx = new C_OrderedWrite(m_ictx->cct, result, trace, this);
ctx = util::create_async_context_callback(*m_ictx, ctx);
+ auto io_context = m_ictx->duplicate_data_io_context();
+ if (!snapc.empty()) {
+ io_context->write_snap_context(
+ {{snapc.seq, {snapc.snaps.begin(), snapc.snaps.end()}}});
+ }
+
auto req = io::ObjectDispatchSpec::create_write(
m_ictx, io::OBJECT_DISPATCH_LAYER_CACHE, object_no, off, std::move(bl_copy),
- snapc, 0, 0, std::nullopt, journal_tid, trace, ctx);
+ io_context, 0, 0, std::nullopt, journal_tid, trace, ctx);
req->object_dispatch_flags = (
io::OBJECT_DISPATCH_FLAG_FLUSH |
io::OBJECT_DISPATCH_FLAG_WILL_RETRY_ON_ERROR);
// vim: ts=8 sw=2 smarttab
#include "common/errno.h"
+#include "include/neorados/RADOS.hpp"
#include "librbd/ImageCtx.h"
#include "librbd/Utils.h"
#include "librbd/asio/ContextWQ.h"
template <typename I>
bool ParentCacheObjectDispatch<I>::read(
- uint64_t object_no, const io::Extents &extents, librados::snap_t snap_id,
+ uint64_t object_no, const io::Extents &extents, IOContext io_context,
int op_flags, const ZTracer::Trace &parent_trace,
ceph::bufferlist* read_data, io::Extents* extent_map, uint64_t* version,
int* object_dispatch_flags, io::DispatchResult* dispatch_result,
CacheGenContextURef ctx = make_gen_lambda_context<ObjectCacheRequest*,
std::function<void(ObjectCacheRequest*)>>
- ([this, read_data, dispatch_result, on_dispatched, object_no,
- object_off = object_off, object_len = object_len, snap_id, &parent_trace]
+ ([this, read_data, dispatch_result, on_dispatched, object_no,
+ object_off = object_off, object_len = object_len, io_context,
+ &parent_trace]
(ObjectCacheRequest* ack) {
- handle_read_cache(ack, object_no, object_off, object_len, snap_id,
+ handle_read_cache(ack, object_no, object_off, object_len, io_context,
parent_trace, read_data, dispatch_result,
on_dispatched);
});
m_cache_client->lookup_object(m_image_ctx->data_ctx.get_namespace(),
m_image_ctx->data_ctx.get_id(),
- (uint64_t)snap_id, oid, std::move(ctx));
+ io_context->read_snap().value_or(CEPH_NOSNAP),
+ oid, std::move(ctx));
return true;
}
template <typename I>
void ParentCacheObjectDispatch<I>::handle_read_cache(
ObjectCacheRequest* ack, uint64_t object_no, uint64_t read_off,
- uint64_t read_len, librados::snap_t snap_id,
+ uint64_t read_len, IOContext io_context,
const ZTracer::Trace &parent_trace, ceph::bufferlist* read_data,
io::DispatchResult* dispatch_result, Context* on_dispatched) {
auto cct = m_image_ctx->cct;
on_dispatched->complete(r);
});
m_plugin_api.read_parent(m_image_ctx, object_no, {{read_off, read_len}},
- snap_id, parent_trace, read_data, ctx);
+ io_context->read_snap().value_or(CEPH_NOSNAP),
+ parent_trace, read_data, ctx);
return;
}
}
bool read(
- uint64_t object_no, const io::Extents &extents, librados::snap_t snap_id,
+ uint64_t object_no, const io::Extents &extents, IOContext io_context,
int op_flags, const ZTracer::Trace &parent_trace,
ceph::bufferlist* read_data, io::Extents* extent_map,
uint64_t* version, int* object_dispatch_flags,
Context* on_dispatched) override;
bool discard(
- uint64_t object_no, uint64_t object_off, uint64_t object_len,
- const ::SnapContext &snapc, int discard_flags,
+ uint64_t object_no, uint64_t object_off, uint64_t object_len,
+ IOContext io_context, int discard_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, io::DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) {
bool write(
uint64_t object_no, uint64_t object_off, ceph::bufferlist&& data,
- const ::SnapContext &snapc, int op_flags, int write_flags,
+ IOContext io_context, int op_flags, int write_flags,
std::optional<uint64_t> assert_version,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, io::DispatchResult* dispatch_result,
bool write_same(
uint64_t object_no, uint64_t object_off, uint64_t object_len,
- io::LightweightBufferExtents&& buffer_extents, ceph::bufferlist&& data,
- const ::SnapContext &snapc, int op_flags,
+ io::LightweightBufferExtents&& buffer_extents, ceph::bufferlist&& data,
+ IOContext io_context, int op_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, io::DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) {
}
bool compare_and_write(
- uint64_t object_no, uint64_t object_off, ceph::bufferlist&& cmp_data,
- ceph::bufferlist&& write_data, const ::SnapContext &snapc, int op_flags,
+ uint64_t object_no, uint64_t object_off, ceph::bufferlist&& cmp_data,
+ ceph::bufferlist&& write_data, IOContext io_context, int op_flags,
const ZTracer::Trace &parent_trace, uint64_t* mismatch_offset,
int* object_dispatch_flags, uint64_t* journal_tid,
io::DispatchResult* dispatch_result, Context** on_finish,
uint64_t offset, uint64_t length, Context *on_finish);
void handle_read_cache(ceph::immutable_obj_cache::ObjectCacheRequest* ack,
uint64_t object_no, uint64_t read_off,
- uint64_t read_len, librados::snap_t snap_id,
+ uint64_t read_len, IOContext io_context,
const ZTracer::Trace &parent_trace,
ceph::bufferlist* read_data,
io::DispatchResult* dispatch_result,
template <typename I>
bool WriteAroundObjectDispatch<I>::read(
- uint64_t object_no, const io::Extents &extents, librados::snap_t snap_id,
+ uint64_t object_no, const io::Extents &extents, IOContext io_context,
int op_flags, const ZTracer::Trace &parent_trace,
ceph::bufferlist* read_data, io::Extents* extent_map, uint64_t* version,
int* object_dispatch_flags, io::DispatchResult* dispatch_result,
template <typename I>
bool WriteAroundObjectDispatch<I>::discard(
uint64_t object_no, uint64_t object_off, uint64_t object_len,
- const ::SnapContext &snapc, int discard_flags,
+ IOContext io_context, int discard_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, io::DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) {
template <typename I>
bool WriteAroundObjectDispatch<I>::write(
uint64_t object_no, uint64_t object_off, ceph::bufferlist&& data,
- const ::SnapContext &snapc, int op_flags, int write_flags,
+ IOContext io_context, int op_flags, int write_flags,
std::optional<uint64_t> assert_version,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, io::DispatchResult* dispatch_result,
bool WriteAroundObjectDispatch<I>::write_same(
uint64_t object_no, uint64_t object_off, uint64_t object_len,
io::LightweightBufferExtents&& buffer_extents, ceph::bufferlist&& data,
- const ::SnapContext &snapc, int op_flags,
+ IOContext io_context, int op_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, io::DispatchResult* dispatch_result,
Context**on_finish, Context* on_dispatched) {
template <typename I>
bool WriteAroundObjectDispatch<I>::compare_and_write(
uint64_t object_no, uint64_t object_off, ceph::bufferlist&& cmp_data,
- ceph::bufferlist&& write_data, const ::SnapContext &snapc, int op_flags,
+ ceph::bufferlist&& write_data, IOContext io_context, int op_flags,
const ZTracer::Trace &parent_trace, uint64_t* mismatch_offset,
int* object_dispatch_flags, uint64_t* journal_tid,
io::DispatchResult* dispatch_result, Context** on_finish,
void shut_down(Context* on_finish) override;
bool read(
- uint64_t object_no, const io::Extents &extents, librados::snap_t snap_id,
+ uint64_t object_no, const io::Extents &extents, IOContext io_context,
int op_flags, const ZTracer::Trace &parent_trace,
ceph::bufferlist* read_data, io::Extents* extent_map,
uint64_t* version, int* object_dispatch_flags,
bool discard(
uint64_t object_no, uint64_t object_off, uint64_t object_len,
- const ::SnapContext &snapc, int discard_flags,
+ IOContext io_context, int discard_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, io::DispatchResult* dispatch_result,
Context**on_finish, Context* on_dispatched) override;
bool write(
uint64_t object_no, uint64_t object_off, ceph::bufferlist&& data,
- const ::SnapContext &snapc, int op_flags, int write_flags,
+ IOContext io_context, int op_flags, int write_flags,
std::optional<uint64_t> assert_version,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, io::DispatchResult* dispatch_result,
bool write_same(
uint64_t object_no, uint64_t object_off, uint64_t object_len,
io::LightweightBufferExtents&& buffer_extents, ceph::bufferlist&& data,
- const ::SnapContext &snapc, int op_flags,
+ IOContext io_context, int op_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, io::DispatchResult* dispatch_result,
Context**on_finish, Context* on_dispatched) override;
bool compare_and_write(
uint64_t object_no, uint64_t object_off, ceph::bufferlist&& cmp_data,
- ceph::bufferlist&& write_data, const ::SnapContext &snapc, int op_flags,
+ ceph::bufferlist&& write_data, IOContext io_context, int op_flags,
const ZTracer::Trace &parent_trace, uint64_t* mismatch_offset,
int* object_dispatch_flags, uint64_t* journal_tid,
io::DispatchResult* dispatch_result, Context** on_finish,
C_EncryptedObjectReadRequest(
I* image_ctx, CryptoInterface* crypto, uint64_t object_no,
- uint64_t object_off, uint64_t object_len, librados::snap_t snap_id,
+ uint64_t object_off, uint64_t object_len, IOContext io_context,
int op_flags, const ZTracer::Trace &parent_trace,
ceph::bufferlist* read_data, int* object_dispatch_flags,
Context** on_finish,
req = io::ObjectDispatchSpec::create_read(
image_ctx, io::OBJECT_DISPATCH_LAYER_CRYPTO, object_no,
- {{object_off, object_len}}, snap_id, op_flags, parent_trace,
+ {{object_off, object_len}}, io_context, op_flags, parent_trace,
&req_comp->bl, &req_comp->extent_map, nullptr, req_comp);
}
template <typename I>
bool CryptoObjectDispatch<I>::read(
uint64_t object_no, const io::Extents &extents,
- librados::snap_t snap_id, int op_flags, const ZTracer::Trace &parent_trace,
+ IOContext io_context, int op_flags, const ZTracer::Trace &parent_trace,
ceph::bufferlist* read_data, io::Extents* extent_map, uint64_t* version,
int* object_dispatch_flags, io::DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) {
*dispatch_result = io::DISPATCH_RESULT_COMPLETE;
auto req = new C_EncryptedObjectReadRequest<I>(
- m_image_ctx, m_crypto, object_no, object_off, object_len, snap_id,
+ m_image_ctx, m_crypto, object_no, object_off, object_len, io_context,
op_flags, parent_trace, read_data, object_dispatch_flags, on_finish,
on_dispatched);
req->send();
template <typename I>
bool CryptoObjectDispatch<I>::write(
uint64_t object_no, uint64_t object_off, ceph::bufferlist&& data,
- const ::SnapContext &snapc, int op_flags, int write_flags,
+ IOContext io_context, int op_flags, int write_flags,
std::optional<uint64_t> assert_version,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, io::DispatchResult* dispatch_result,
bool CryptoObjectDispatch<I>::write_same(
uint64_t object_no, uint64_t object_off, uint64_t object_len,
io::LightweightBufferExtents&& buffer_extents, ceph::bufferlist&& data,
- const ::SnapContext &snapc, int op_flags,
+ IOContext io_context, int op_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, io::DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) {
*dispatch_result = io::DISPATCH_RESULT_COMPLETE;
auto req = io::ObjectDispatchSpec::create_write(
m_image_ctx, io::OBJECT_DISPATCH_LAYER_NONE, object_no,
- object_off, std::move(ws_data), snapc, op_flags, 0, std::nullopt, 0,
- parent_trace, ctx);
+ object_off, std::move(ws_data), io_context, op_flags, 0, std::nullopt,
+ 0, parent_trace, ctx);
req->send();
return true;
}
template <typename I>
bool CryptoObjectDispatch<I>::compare_and_write(
uint64_t object_no, uint64_t object_off, ceph::bufferlist&& cmp_data,
- ceph::bufferlist&& write_data, const ::SnapContext &snapc, int op_flags,
+ ceph::bufferlist&& write_data, IOContext io_context, int op_flags,
const ZTracer::Trace &parent_trace, uint64_t* mismatch_offset,
int* object_dispatch_flags, uint64_t* journal_tid,
io::DispatchResult* dispatch_result, Context** on_finish,
template <typename I>
bool CryptoObjectDispatch<I>::discard(
uint64_t object_no, uint64_t object_off, uint64_t object_len,
- const ::SnapContext &snapc, int discard_flags,
+ IOContext io_context, int discard_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, io::DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) {
*dispatch_result = io::DISPATCH_RESULT_COMPLETE;
auto req = io::ObjectDispatchSpec::create_write_same(
m_image_ctx, io::OBJECT_DISPATCH_LAYER_NONE, object_no, object_off,
- object_len, {{0, buffer_size}}, std::move(bl), snapc,
+ object_len, {{0, buffer_size}}, std::move(bl), io_context,
*object_dispatch_flags, 0, parent_trace, ctx);
req->send();
return true;
struct ImageCtx;
namespace crypto {
-
+
template <typename ImageCtxT = librbd::ImageCtx>
class CryptoObjectDispatch : public io::ObjectDispatchInterface {
public:
bool read(
uint64_t object_no, const io::Extents &extents,
- librados::snap_t snap_id, int op_flags,
+ IOContext io_context, int op_flags,
const ZTracer::Trace &parent_trace, ceph::bufferlist* read_data,
io::Extents* extent_map, uint64_t* version, int* object_dispatch_flags,
io::DispatchResult* dispatch_result, Context** on_finish,
bool discard(
uint64_t object_no, uint64_t object_off, uint64_t object_len,
- const ::SnapContext &snapc, int discard_flags,
+ IOContext io_context, int discard_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, io::DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) override;
bool write(
uint64_t object_no, uint64_t object_off, ceph::bufferlist&& data,
- const ::SnapContext &snapc, int op_flags, int write_flags,
+ IOContext io_context, int op_flags, int write_flags,
std::optional<uint64_t> assert_version,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, io::DispatchResult* dispatch_result,
bool write_same(
uint64_t object_no, uint64_t object_off, uint64_t object_len,
io::LightweightBufferExtents&& buffer_extents, ceph::bufferlist&& data,
- const ::SnapContext &snapc, int op_flags,
+ IOContext io_context, int op_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, io::DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) override;
bool compare_and_write(
uint64_t object_no, uint64_t object_off, ceph::bufferlist&& cmp_data,
- ceph::bufferlist&& write_data, const ::SnapContext &snapc, int op_flags,
+ ceph::bufferlist&& write_data, IOContext io_context, int op_flags,
const ZTracer::Trace &parent_trace, uint64_t* mismatch_offset,
int* object_dispatch_flags, uint64_t* journal_tid,
io::DispatchResult* dispatch_result, Context** on_finish,
}
uint64_t image_size = ictx->get_image_size(ictx->snap_id);
- auto snap_id = 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;
object_extent.length);
auto req = io::ObjectDispatchSpec::create_read(
ictx, io::OBJECT_DISPATCH_LAYER_NONE, object_extent.object_no,
- {{object_extent.offset, object_extent.length}}, snap_id, 0, {},
+ {{object_extent.offset, object_extent.length}}, io_context, 0, {},
&req_comp->read_data, &req_comp->extent_map, nullptr, req_comp);
req->send();
}
readahead(get_image_ctx(&image_ctx), image_extents);
}
- librados::snap_t snap_id;
- uint64_t buffer_ofs = 0;
- {
- // prevent image size from changing between computing clip and recording
- // pending async operation
- std::shared_lock image_locker{image_ctx.image_lock};
- snap_id = image_ctx.snap_id;
- }
-
// map image extents to object extents
LightweightObjectExtents object_extents;
+ uint64_t buffer_ofs = 0;
for (auto &extent : image_extents) {
if (extent.second == 0) {
continue;
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}}, snap_id, m_op_flags, this->m_trace,
+ {{oe.offset, oe.length}}, io_context, m_op_flags, this->m_trace,
&req_comp->bl, &req_comp->extent_map, nullptr, req_comp);
req->send();
}
bool journaling = false;
+ auto io_context = image_ctx.get_data_io_context();
AioCompletion *aio_comp = this->m_aio_comp;
- ::SnapContext snapc;
{
// prevent image size from changing between computing clip and recording
// pending async operation
std::shared_lock image_locker{image_ctx.image_lock};
-
- snapc = image_ctx.snapc;
journaling = (image_ctx.journal != nullptr &&
image_ctx.journal->is_journal_appending());
}
journal_tid = append_journal_event(m_synchronous);
}
- send_object_requests(object_extents, snapc, journal_tid);
+ send_object_requests(object_extents, io_context, journal_tid);
}
update_stats(clip_len);
template <typename I>
void AbstractImageWriteRequest<I>::send_object_requests(
- const LightweightObjectExtents &object_extents, const ::SnapContext &snapc,
+ const LightweightObjectExtents &object_extents, IOContext io_context,
uint64_t journal_tid) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
<< oe.offset << "~" << oe.length << " from "
<< oe.buffer_extents << dendl;
C_AioRequest *req_comp = new C_AioRequest(aio_comp);
- auto request = create_object_request(oe, snapc, journal_tid, single_extent,
- req_comp);
+ auto request = create_object_request(oe, io_context, journal_tid,
+ single_extent, req_comp);
request->send();
}
}
template <typename I>
ObjectDispatchSpec *ImageWriteRequest<I>::create_object_request(
- const LightweightObjectExtent &object_extent, const ::SnapContext &snapc,
+ const LightweightObjectExtent &object_extent, IOContext io_context,
uint64_t journal_tid, bool single_extent, Context *on_finish) {
I &image_ctx = this->m_image_ctx;
auto req = ObjectDispatchSpec::create_write(
&image_ctx, OBJECT_DISPATCH_LAYER_NONE, object_extent.object_no,
- object_extent.offset, std::move(bl), snapc, m_op_flags, 0, std::nullopt,
- journal_tid, this->m_trace, on_finish);
+ object_extent.offset, std::move(bl), io_context, m_op_flags, 0,
+ std::nullopt, journal_tid, this->m_trace, on_finish);
return req;
}
template <typename I>
ObjectDispatchSpec *ImageDiscardRequest<I>::create_object_request(
- const LightweightObjectExtent &object_extent, const ::SnapContext &snapc,
+ const LightweightObjectExtent &object_extent, IOContext io_context,
uint64_t journal_tid, bool single_extent, Context *on_finish) {
I &image_ctx = this->m_image_ctx;
auto req = ObjectDispatchSpec::create_discard(
&image_ctx, OBJECT_DISPATCH_LAYER_NONE, object_extent.object_no,
- object_extent.offset, object_extent.length, snapc,
+ object_extent.offset, object_extent.length, io_context,
OBJECT_DISCARD_FLAG_DISABLE_CLONE_REMOVE, journal_tid, this->m_trace,
on_finish);
return req;
template <typename I>
ObjectDispatchSpec *ImageWriteSameRequest<I>::create_object_request(
- const LightweightObjectExtent &object_extent, const ::SnapContext &snapc,
+ const LightweightObjectExtent &object_extent, IOContext io_context,
uint64_t journal_tid, bool single_extent, Context *on_finish) {
I &image_ctx = this->m_image_ctx;
req = ObjectDispatchSpec::create_write_same(
&image_ctx, OBJECT_DISPATCH_LAYER_NONE, object_extent.object_no,
object_extent.offset, object_extent.length, std::move(buffer_extents),
- std::move(bl), snapc, m_op_flags, journal_tid,
+ std::move(bl), io_context, m_op_flags, journal_tid,
this->m_trace, on_finish);
return req;
}
req = ObjectDispatchSpec::create_write(
&image_ctx, OBJECT_DISPATCH_LAYER_NONE, object_extent.object_no,
- object_extent.offset, std::move(bl), snapc, m_op_flags, 0, std::nullopt,
- journal_tid, this->m_trace, on_finish);
+ object_extent.offset, std::move(bl), io_context, m_op_flags, 0,
+ std::nullopt, journal_tid, this->m_trace, on_finish);
return req;
}
template <typename I>
ObjectDispatchSpec *ImageCompareAndWriteRequest<I>::create_object_request(
- const LightweightObjectExtent &object_extent, const ::SnapContext &snapc,
+ const LightweightObjectExtent &object_extent, IOContext io_context,
uint64_t journal_tid, bool single_extent, Context *on_finish) {
I &image_ctx = this->m_image_ctx;
assemble_extent(object_extent, &bl);
auto req = ObjectDispatchSpec::create_compare_and_write(
&image_ctx, OBJECT_DISPATCH_LAYER_NONE, object_extent.object_no,
- object_extent.offset, std::move(m_cmp_bl), std::move(bl), snapc,
+ object_extent.offset, std::move(m_cmp_bl), std::move(bl), io_context,
m_mismatch_offset, m_op_flags, journal_tid, this->m_trace, on_finish);
return req;
}
#include "include/int_types.h"
#include "include/buffer_fwd.h"
-#include "common/snap_types.h"
#include "common/zipkin_trace.h"
#include "osd/osd_types.h"
#include "librbd/Utils.h"
+#include "librbd/Types.h"
#include "librbd/io/Types.h"
#include <list>
#include <utility>
}
void send_object_requests(const LightweightObjectExtents &object_extents,
- const ::SnapContext &snapc, uint64_t journal_tid);
+ IOContext io_context, uint64_t journal_tid);
virtual ObjectDispatchSpec *create_object_request(
- const LightweightObjectExtent &object_extent, const ::SnapContext &snapc,
+ const LightweightObjectExtent &object_extent, IOContext io_context,
uint64_t journal_tid, bool single_extent, Context *on_finish) = 0;
virtual uint64_t append_journal_event(bool synchronous) = 0;
ObjectDispatchSpec *create_object_request(
- const LightweightObjectExtent &object_extent, const ::SnapContext &snapc,
+ const LightweightObjectExtent &object_extent, IOContext io_context,
uint64_t journal_tid, bool single_extent, Context *on_finish) override;
uint64_t append_journal_event(bool synchronous) override;
void send_image_cache_request() override;
ObjectDispatchSpec *create_object_request(
- const LightweightObjectExtent &object_extent, const ::SnapContext &snapc,
+ const LightweightObjectExtent &object_extent, IOContext io_context,
uint64_t journal_tid, bool single_extent, Context *on_finish) override;
uint64_t append_journal_event(bool synchronous) override;
void send_image_cache_request() override;
ObjectDispatchSpec *create_object_request(
- const LightweightObjectExtent &object_extent, const ::SnapContext &snapc,
+ const LightweightObjectExtent &object_extent, IOContext io_context,
uint64_t journal_tid, bool single_extent, Context *on_finish) override;
uint64_t append_journal_event(bool synchronous) override;
bufferlist *bl);
ObjectDispatchSpec *create_object_request(
- const LightweightObjectExtent &object_extent, const ::SnapContext &snapc,
+ const LightweightObjectExtent &object_extent, IOContext io_context,
uint64_t journal_tid, bool single_extent, Context *on_finish) override;
uint64_t append_journal_event(bool synchronous) override;
template <typename I>
bool ObjectDispatch<I>::read(
- uint64_t object_no, const Extents &extents, librados::snap_t snap_id,
+ uint64_t object_no, const Extents &extents, IOContext io_context,
int op_flags, const ZTracer::Trace &parent_trace,
ceph::bufferlist* read_data, Extents* extent_map, uint64_t* version,
int* object_dispatch_flags, DispatchResult* dispatch_result,
ldout(cct, 20) << "object_no=" << object_no << " " << extents << dendl;
*dispatch_result = DISPATCH_RESULT_COMPLETE;
- auto req = new ObjectReadRequest<I>(m_image_ctx, object_no, extents, snap_id,
- op_flags, parent_trace, read_data,
- extent_map, version, on_dispatched);
+ auto req = new ObjectReadRequest<I>(m_image_ctx, object_no, extents,
+ io_context, op_flags, parent_trace,
+ read_data, extent_map, version,
+ on_dispatched);
req->send();
return true;
}
template <typename I>
bool ObjectDispatch<I>::discard(
uint64_t object_no, uint64_t object_off, uint64_t object_len,
- const ::SnapContext &snapc, int discard_flags,
+ IOContext io_context, int discard_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) {
*dispatch_result = DISPATCH_RESULT_COMPLETE;
auto req = new ObjectDiscardRequest<I>(m_image_ctx, object_no, object_off,
- object_len, snapc, discard_flags,
+ object_len, io_context, discard_flags,
parent_trace, on_dispatched);
req->send();
return true;
template <typename I>
bool ObjectDispatch<I>::write(
uint64_t object_no, uint64_t object_off, ceph::bufferlist&& data,
- const ::SnapContext &snapc, int op_flags, int write_flags,
+ IOContext io_context, int op_flags, int write_flags,
std::optional<uint64_t> assert_version,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, DispatchResult* dispatch_result,
*dispatch_result = DISPATCH_RESULT_COMPLETE;
auto req = new ObjectWriteRequest<I>(m_image_ctx, object_no, object_off,
- std::move(data), snapc, op_flags,
+ std::move(data), io_context, op_flags,
write_flags, assert_version,
parent_trace, on_dispatched);
req->send();
bool ObjectDispatch<I>::write_same(
uint64_t object_no, uint64_t object_off, uint64_t object_len,
LightweightBufferExtents&& buffer_extents, ceph::bufferlist&& data,
- const ::SnapContext &snapc, int op_flags,
+ IOContext io_context, int op_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) {
*dispatch_result = DISPATCH_RESULT_COMPLETE;
auto req = new ObjectWriteSameRequest<I>(m_image_ctx, object_no,
object_off, object_len,
- std::move(data), snapc, op_flags,
- parent_trace, on_dispatched);
+ std::move(data), io_context,
+ op_flags, parent_trace,
+ on_dispatched);
req->send();
return true;
}
template <typename I>
bool ObjectDispatch<I>::compare_and_write(
uint64_t object_no, uint64_t object_off, ceph::bufferlist&& cmp_data,
- ceph::bufferlist&& write_data, const ::SnapContext &snapc, int op_flags,
+ ceph::bufferlist&& write_data, IOContext io_context, int op_flags,
const ZTracer::Trace &parent_trace, uint64_t* mismatch_offset,
int* object_dispatch_flags, uint64_t* journal_tid,
DispatchResult* dispatch_result, Context** on_finish,
auto req = new ObjectCompareAndWriteRequest<I>(m_image_ctx, object_no,
object_off,
std::move(cmp_data),
- std::move(write_data), snapc,
- mismatch_offset, op_flags,
- parent_trace, on_dispatched);
+ std::move(write_data),
+ io_context, mismatch_offset,
+ op_flags, parent_trace,
+ on_dispatched);
req->send();
return true;
}
#include "include/int_types.h"
#include "include/buffer.h"
#include "include/rados/librados.hpp"
-#include "common/snap_types.h"
#include "common/zipkin_trace.h"
#include "librbd/io/Types.h"
#include "librbd/io/ObjectDispatchInterface.h"
void shut_down(Context* on_finish) override;
bool read(
- uint64_t object_no, const Extents &extents, librados::snap_t snap_id,
+ uint64_t object_no, const Extents &extents, IOContext io_context,
int op_flags, const ZTracer::Trace &parent_trace,
ceph::bufferlist* read_data, Extents* extent_map,
uint64_t* version, int* object_dispatch_flags,
bool discard(
uint64_t object_no, uint64_t object_off, uint64_t object_len,
- const ::SnapContext &snapc, int discard_flags,
+ IOContext io_context, int discard_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) override;
bool write(
uint64_t object_no, uint64_t object_off, ceph::bufferlist&& data,
- const ::SnapContext &snapc, int op_flags, int write_flags,
+ IOContext io_context, int op_flags, int write_flags,
std::optional<uint64_t> assert_version,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, DispatchResult* dispatch_result,
bool write_same(
uint64_t object_no, uint64_t object_off, uint64_t object_len,
LightweightBufferExtents&& buffer_extents, ceph::bufferlist&& data,
- const ::SnapContext &snapc, int op_flags,
+ IOContext io_context, int op_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) override;
bool compare_and_write(
uint64_t object_no, uint64_t object_off, ceph::bufferlist&& cmp_data,
- ceph::bufferlist&& write_data, const ::SnapContext &snapc, int op_flags,
+ ceph::bufferlist&& write_data, IOContext io_context, int op_flags,
const ZTracer::Trace &parent_trace, uint64_t* mismatch_offset,
int* object_dispatch_flags, uint64_t* journal_tid,
DispatchResult* dispatch_result, Context** on_finish,
#include "include/int_types.h"
#include "include/buffer.h"
#include "include/rados/librados.hpp"
-#include "common/snap_types.h"
#include "common/zipkin_trace.h"
+#include "librbd/Types.h"
#include "librbd/io/Types.h"
struct Context;
virtual bool read(
uint64_t object_no, const Extents &extents,
- librados::snap_t snap_id, int op_flags, const ZTracer::Trace &parent_trace,
+ IOContext io_context, int op_flags, const ZTracer::Trace &parent_trace,
ceph::bufferlist* read_data, Extents* extent_map, uint64_t* version,
int* object_dispatch_flags, DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) = 0;
virtual bool discard(
uint64_t object_no, uint64_t object_off, uint64_t object_len,
- const ::SnapContext &snapc, int discard_flags,
+ IOContext io_context, int discard_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, DispatchResult* dispatch_result,
Context**on_finish, Context* on_dispatched) = 0;
virtual bool write(
uint64_t object_no, uint64_t object_off, ceph::bufferlist&& data,
- const ::SnapContext &snapc, int op_flags, int write_flags,
+ IOContext io_context, int op_flags, int write_flags,
std::optional<uint64_t> assert_version,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, DispatchResult* dispatch_result,
virtual bool write_same(
uint64_t object_no, uint64_t object_off, uint64_t object_len,
LightweightBufferExtents&& buffer_extents, ceph::bufferlist&& data,
- const ::SnapContext &snapc, int op_flags,
- const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
- uint64_t* journal_tid, DispatchResult* dispatch_result,
- Context**on_finish, Context* on_dispatched) = 0;
+ IOContext io_context, int op_flags, const ZTracer::Trace &parent_trace,
+ int* object_dispatch_flags, uint64_t* journal_tid,
+ DispatchResult* dispatch_result, Context**on_finish,
+ Context* on_dispatched) = 0;
virtual bool compare_and_write(
uint64_t object_no, uint64_t object_off, ceph::bufferlist&& cmp_data,
- ceph::bufferlist&& write_data, const ::SnapContext &snapc, int op_flags,
+ ceph::bufferlist&& write_data, IOContext io_context, int op_flags,
const ZTracer::Trace &parent_trace, uint64_t* mismatch_offset,
int* object_dispatch_flags, uint64_t* journal_tid,
DispatchResult* dispatch_result, Context** on_finish,
#include "include/buffer.h"
#include "include/Context.h"
#include "include/rados/librados.hpp"
-#include "common/snap_types.h"
#include "common/zipkin_trace.h"
+#include "librbd/Types.h"
#include "librbd/io/Types.h"
#include <boost/variant/variant.hpp>
struct ReadRequest : public RequestBase {
const Extents extents;
- librados::snap_t snap_id;
ceph::bufferlist* read_data;
Extents* extent_map;
uint64_t* version;
ReadRequest(uint64_t object_no, const Extents &extents,
- librados::snap_t snap_id, ceph::bufferlist* read_data,
- Extents* extent_map, uint64_t* version)
- : RequestBase(object_no), extents(extents), snap_id(snap_id),
- read_data(read_data), extent_map(extent_map), version(version) {
+ ceph::bufferlist* read_data, Extents* extent_map,
+ uint64_t* version)
+ : RequestBase(object_no), extents(extents), read_data(read_data),
+ extent_map(extent_map), version(version) {
}
};
struct WriteRequestBase : public RequestBase {
uint64_t object_off;
- ::SnapContext snapc;
uint64_t journal_tid;
WriteRequestBase(uint64_t object_no, uint64_t object_off,
- const ::SnapContext& snapc, uint64_t journal_tid)
- : RequestBase(object_no), object_off(object_off), snapc(snapc),
+ uint64_t journal_tid)
+ : RequestBase(object_no), object_off(object_off),
journal_tid(journal_tid) {
}
};
int discard_flags;
DiscardRequest(uint64_t object_no, uint64_t object_off, uint64_t object_len,
- int discard_flags, const ::SnapContext& snapc,
- uint64_t journal_tid)
- : WriteRequestBase(object_no, object_off, snapc, journal_tid),
+ int discard_flags, uint64_t journal_tid)
+ : WriteRequestBase(object_no, object_off, journal_tid),
object_len(object_len), discard_flags(discard_flags) {
}
};
std::optional<uint64_t> assert_version;
WriteRequest(uint64_t object_no, uint64_t object_off,
- ceph::bufferlist&& data, const ::SnapContext& snapc,
- int write_flags, std::optional<uint64_t> assert_version,
- uint64_t journal_tid)
- : WriteRequestBase(object_no, object_off, snapc, journal_tid),
+ ceph::bufferlist&& data, int write_flags,
+ std::optional<uint64_t> assert_version, uint64_t journal_tid)
+ : WriteRequestBase(object_no, object_off, journal_tid),
data(std::move(data)), write_flags(write_flags),
assert_version(assert_version) {
}
WriteSameRequest(uint64_t object_no, uint64_t object_off,
uint64_t object_len,
LightweightBufferExtents&& buffer_extents,
- ceph::bufferlist&& data, const ::SnapContext& snapc,
- uint64_t journal_tid)
- : WriteRequestBase(object_no, object_off, snapc, journal_tid),
+ ceph::bufferlist&& data, uint64_t journal_tid)
+ : WriteRequestBase(object_no, object_off, journal_tid),
object_len(object_len), buffer_extents(std::move(buffer_extents)),
data(std::move(data)) {
}
CompareAndWriteRequest(uint64_t object_no, uint64_t object_off,
ceph::bufferlist&& cmp_data, ceph::bufferlist&& data,
uint64_t* mismatch_offset,
- const ::SnapContext& snapc, uint64_t journal_tid)
- : WriteRequestBase(object_no, object_off, snapc, journal_tid),
+ uint64_t journal_tid)
+ : WriteRequestBase(object_no, object_off, journal_tid),
cmp_data(std::move(cmp_data)), data(std::move(data)),
mismatch_offset(mismatch_offset) {
}
DispatchResult dispatch_result = DISPATCH_RESULT_INVALID;
Request request;
+ IOContext io_context;
int op_flags;
ZTracer::Trace parent_trace;
template <typename ImageCtxT>
static ObjectDispatchSpec* create_read(
ImageCtxT* image_ctx, ObjectDispatchLayer object_dispatch_layer,
- uint64_t object_no, const Extents &extents, librados::snap_t snap_id,
+ uint64_t object_no, const Extents &extents, IOContext io_context,
int op_flags, const ZTracer::Trace &parent_trace,
ceph::bufferlist* read_data, Extents* extent_map, uint64_t* version,
Context* on_finish) {
return new ObjectDispatchSpec(image_ctx->io_object_dispatcher,
object_dispatch_layer,
- ReadRequest{object_no, extents, snap_id,
+ ReadRequest{object_no, extents,
read_data, extent_map, version},
- op_flags, parent_trace, on_finish);
+ io_context, op_flags, parent_trace,
+ on_finish);
}
template <typename ImageCtxT>
static ObjectDispatchSpec* create_discard(
ImageCtxT* image_ctx, ObjectDispatchLayer object_dispatch_layer,
uint64_t object_no, uint64_t object_off, uint64_t object_len,
- const ::SnapContext &snapc, int discard_flags, uint64_t journal_tid,
+ IOContext io_context, int discard_flags, uint64_t journal_tid,
const ZTracer::Trace &parent_trace, Context *on_finish) {
return new ObjectDispatchSpec(image_ctx->io_object_dispatcher,
object_dispatch_layer,
DiscardRequest{object_no, object_off,
object_len, discard_flags,
- snapc, journal_tid},
- 0, parent_trace, on_finish);
+ journal_tid},
+ io_context, 0, parent_trace, on_finish);
}
template <typename ImageCtxT>
static ObjectDispatchSpec* create_write(
ImageCtxT* image_ctx, ObjectDispatchLayer object_dispatch_layer,
uint64_t object_no, uint64_t object_off, ceph::bufferlist&& data,
- const ::SnapContext &snapc, int op_flags, int write_flags,
+ IOContext io_context, int op_flags, int write_flags,
std::optional<uint64_t> assert_version, uint64_t journal_tid,
const ZTracer::Trace &parent_trace, Context *on_finish) {
return new ObjectDispatchSpec(image_ctx->io_object_dispatcher,
object_dispatch_layer,
WriteRequest{object_no, object_off,
- std::move(data), snapc,
- write_flags, assert_version,
- journal_tid},
- op_flags, parent_trace, on_finish);
+ std::move(data), write_flags,
+ assert_version, journal_tid},
+ io_context, op_flags, parent_trace,
+ on_finish);
}
template <typename ImageCtxT>
ImageCtxT* image_ctx, ObjectDispatchLayer object_dispatch_layer,
uint64_t object_no, uint64_t object_off, uint64_t object_len,
LightweightBufferExtents&& buffer_extents, ceph::bufferlist&& data,
- const ::SnapContext &snapc, int op_flags, uint64_t journal_tid,
+ IOContext io_context, int op_flags, uint64_t journal_tid,
const ZTracer::Trace &parent_trace, Context *on_finish) {
return new ObjectDispatchSpec(image_ctx->io_object_dispatcher,
object_dispatch_layer,
WriteSameRequest{object_no, object_off,
object_len,
std::move(buffer_extents),
- std::move(data), snapc,
+ std::move(data),
journal_tid},
- op_flags, parent_trace, on_finish);
+ io_context, op_flags, parent_trace,
+ on_finish);
}
template <typename ImageCtxT>
static ObjectDispatchSpec* create_compare_and_write(
ImageCtxT* image_ctx, ObjectDispatchLayer object_dispatch_layer,
uint64_t object_no, uint64_t object_off, ceph::bufferlist&& cmp_data,
- ceph::bufferlist&& write_data, const ::SnapContext &snapc,
+ ceph::bufferlist&& write_data, IOContext io_context,
uint64_t *mismatch_offset, int op_flags, uint64_t journal_tid,
const ZTracer::Trace &parent_trace, Context *on_finish) {
return new ObjectDispatchSpec(image_ctx->io_object_dispatcher,
std::move(cmp_data),
std::move(write_data),
mismatch_offset,
- snapc, journal_tid},
- op_flags, parent_trace, on_finish);
+ journal_tid},
+ io_context, op_flags, parent_trace,
+ on_finish);
}
template <typename ImageCtxT>
const ZTracer::Trace &parent_trace, Context *on_finish) {
return new ObjectDispatchSpec(image_ctx->io_object_dispatcher,
object_dispatch_layer,
- FlushRequest{flush_source, journal_tid}, 0,
- parent_trace, on_finish);
+ FlushRequest{flush_source, journal_tid},
+ {}, 0, parent_trace, on_finish);
}
void send();
ObjectDispatchSpec(ObjectDispatcherInterface* object_dispatcher,
ObjectDispatchLayer object_dispatch_layer,
- Request&& request, int op_flags,
+ Request&& request, IOContext io_context, int op_flags,
const ZTracer::Trace& parent_trace, Context* on_finish)
: dispatcher_ctx(this, on_finish), object_dispatcher(object_dispatcher),
dispatch_layer(object_dispatch_layer), request(std::move(request)),
- op_flags(op_flags), parent_trace(parent_trace) {
+ io_context(io_context), op_flags(op_flags), parent_trace(parent_trace) {
}
};
bool operator()(ObjectDispatchSpec::ReadRequest& read) const {
return object_dispatch->read(
- read.object_no, read.extents, read.snap_id,
+ read.object_no, read.extents, object_dispatch_spec->io_context,
object_dispatch_spec->op_flags, object_dispatch_spec->parent_trace,
read.read_data, read.extent_map, read.version,
&object_dispatch_spec->object_dispatch_flags,
bool operator()(ObjectDispatchSpec::DiscardRequest& discard) const {
return object_dispatch->discard(
- discard.object_no, discard.object_off, discard.object_len, discard.snapc,
- discard.discard_flags, object_dispatch_spec->parent_trace,
+ discard.object_no, discard.object_off, discard.object_len,
+ object_dispatch_spec->io_context, discard.discard_flags,
+ object_dispatch_spec->parent_trace,
&object_dispatch_spec->object_dispatch_flags, &discard.journal_tid,
&object_dispatch_spec->dispatch_result,
&object_dispatch_spec->dispatcher_ctx.on_finish,
bool operator()(ObjectDispatchSpec::WriteRequest& write) const {
return object_dispatch->write(
- write.object_no, write.object_off, std::move(write.data), write.snapc,
- object_dispatch_spec->op_flags, write.write_flags, write.assert_version,
+ write.object_no, write.object_off, std::move(write.data),
+ object_dispatch_spec->io_context, object_dispatch_spec->op_flags,
+ write.write_flags, write.assert_version,
object_dispatch_spec->parent_trace,
&object_dispatch_spec->object_dispatch_flags, &write.journal_tid,
&object_dispatch_spec->dispatch_result,
return object_dispatch->write_same(
write_same.object_no, write_same.object_off, write_same.object_len,
std::move(write_same.buffer_extents), std::move(write_same.data),
- write_same.snapc, object_dispatch_spec->op_flags,
+ object_dispatch_spec->io_context, object_dispatch_spec->op_flags,
object_dispatch_spec->parent_trace,
&object_dispatch_spec->object_dispatch_flags, &write_same.journal_tid,
&object_dispatch_spec->dispatch_result,
return object_dispatch->compare_and_write(
compare_and_write.object_no, compare_and_write.object_off,
std::move(compare_and_write.cmp_data), std::move(compare_and_write.data),
- compare_and_write.snapc, object_dispatch_spec->op_flags,
+ object_dispatch_spec->io_context, object_dispatch_spec->op_flags,
object_dispatch_spec->parent_trace, compare_and_write.mismatch_offset,
&object_dispatch_spec->object_dispatch_flags,
&compare_and_write.journal_tid,
namespace {
template <typename I>
-inline bool is_copy_on_read(I *ictx, librados::snap_t snap_id) {
+inline bool is_copy_on_read(I *ictx, const IOContext& io_context) {
std::shared_lock image_locker{ictx->image_lock};
- return (ictx->clone_copy_on_read &&
- !ictx->read_only && snap_id == CEPH_NOSNAP &&
+ return (ictx->clone_copy_on_read && !ictx->read_only &&
+ io_context->read_snap().value_or(CEPH_NOSNAP) == CEPH_NOSNAP &&
(ictx->exclusive_lock == nullptr ||
ictx->exclusive_lock->is_lock_owner()));
}
ObjectRequest<I>*
ObjectRequest<I>::create_write(
I *ictx, uint64_t object_no, uint64_t object_off, ceph::bufferlist&& data,
- const ::SnapContext &snapc, int op_flags, int write_flags,
+ IOContext io_context, int op_flags, int write_flags,
std::optional<uint64_t> assert_version,
const ZTracer::Trace &parent_trace, Context *completion) {
return new ObjectWriteRequest<I>(ictx, object_no, object_off,
- std::move(data), snapc, op_flags,
+ std::move(data), io_context, op_flags,
write_flags, assert_version,
parent_trace, completion);
}
ObjectRequest<I>*
ObjectRequest<I>::create_discard(
I *ictx, uint64_t object_no, uint64_t object_off, uint64_t object_len,
- const ::SnapContext &snapc, int discard_flags,
+ IOContext io_context, int discard_flags,
const ZTracer::Trace &parent_trace, Context *completion) {
return new ObjectDiscardRequest<I>(ictx, object_no, object_off,
- object_len, snapc, discard_flags,
+ object_len, io_context, discard_flags,
parent_trace, completion);
}
ObjectRequest<I>*
ObjectRequest<I>::create_write_same(
I *ictx, uint64_t object_no, uint64_t object_off, uint64_t object_len,
- ceph::bufferlist&& data, const ::SnapContext &snapc, int op_flags,
+ ceph::bufferlist&& data, IOContext io_context, int op_flags,
const ZTracer::Trace &parent_trace, Context *completion) {
return new ObjectWriteSameRequest<I>(ictx, object_no, object_off,
- object_len, std::move(data), snapc,
+ object_len, std::move(data), io_context,
op_flags, parent_trace, completion);
}
ObjectRequest<I>::create_compare_and_write(
I *ictx, uint64_t object_no, uint64_t object_off,
ceph::bufferlist&& cmp_data, ceph::bufferlist&& write_data,
- const ::SnapContext &snapc, uint64_t *mismatch_offset, int op_flags,
+ IOContext io_context, uint64_t *mismatch_offset, int op_flags,
const ZTracer::Trace &parent_trace, Context *completion) {
return new ObjectCompareAndWriteRequest<I>(ictx, object_no, object_off,
std::move(cmp_data),
- std::move(write_data), snapc,
+ std::move(write_data), io_context,
mismatch_offset, op_flags,
parent_trace, completion);
}
template <typename I>
ObjectRequest<I>::ObjectRequest(
- I *ictx, uint64_t objectno, librados::snap_t snap_id,
+ I *ictx, uint64_t objectno, IOContext io_context,
const char *trace_name, const ZTracer::Trace &trace, Context *completion)
- : m_ictx(ictx), m_object_no(objectno), m_snap_id(snap_id),
+ : m_ictx(ictx), m_object_no(objectno), m_io_context(io_context),
m_completion(completion),
m_trace(create_trace(*ictx, "", trace)) {
ceph_assert(m_ictx->data_ctx.is_valid());
parent_extents->clear();
uint64_t parent_overlap;
- int r = m_ictx->get_parent_overlap(m_snap_id, &parent_overlap);
+ int r = m_ictx->get_parent_overlap(
+ m_io_context->read_snap().value_or(CEPH_NOSNAP), &parent_overlap);
if (r < 0) {
// NOTE: it's possible for a snapshot to be deleted while we are
// still reading from it
template <typename I>
ObjectReadRequest<I>::ObjectReadRequest(
I *ictx, uint64_t objectno, const Extents &extents,
- librados::snap_t snap_id, int op_flags, const ZTracer::Trace &parent_trace,
+ IOContext io_context, int op_flags, const ZTracer::Trace &parent_trace,
ceph::bufferlist* read_data, Extents* extent_map, uint64_t* version,
Context *completion)
- : ObjectRequest<I>(ictx, objectno, snap_id, "read",
- parent_trace, completion),
+ : ObjectRequest<I>(ictx, objectno, io_context, "read", parent_trace,
+ completion),
m_extents(extents), m_op_flags(op_flags), m_read_data(read_data),
m_extent_map(extent_map), m_version(version) {
}
template <typename I>
void ObjectReadRequest<I>::read_object() {
I *image_ctx = this->m_ictx;
- {
- std::shared_lock image_locker{image_ctx->image_lock};
- if (image_ctx->object_map != nullptr &&
- !image_ctx->object_map->object_may_exist(this->m_object_no)) {
- image_ctx->asio_engine->post([this]() { read_parent(); });
- return;
- }
+
+ std::shared_lock image_locker{image_ctx->image_lock};
+ auto read_snap_id = this->m_io_context->read_snap().value_or(CEPH_NOSNAP);
+ if (read_snap_id == image_ctx->snap_id &&
+ image_ctx->object_map != nullptr &&
+ !image_ctx->object_map->object_may_exist(this->m_object_no)) {
+ image_ctx->asio_engine->post([this]() { read_parent(); });
+ return;
}
+ image_locker.unlock();
ldout(image_ctx->cct, 20) << dendl;
read_op.read(object_off, object_len, &(extent_result.first));
}
}
- util::apply_op_flags(m_op_flags, image_ctx->get_read_flags(this->m_snap_id),
- &read_op);
+ util::apply_op_flags(
+ m_op_flags, image_ctx->get_read_flags(read_snap_id), &read_op);
image_ctx->rados_api.execute(
{data_object_name(this->m_ictx, this->m_object_no)},
- *image_ctx->get_data_io_context(), std::move(read_op), nullptr,
+ *this->m_io_context, std::move(read_op), nullptr,
librbd::asio::util::get_callback_adapter(
[this](int r) { handle_read_object(r); }), m_version,
(this->m_trace.valid() ? this->m_trace.get_info() : nullptr));
auto ctx = create_context_callback<
ObjectReadRequest<I>, &ObjectReadRequest<I>::handle_read_parent>(this);
- io::util::read_parent<I>(image_ctx, this->m_object_no, this->m_extents,
- this->m_snap_id, this->m_trace, m_read_data, ctx);
+ io::util::read_parent<I>(
+ image_ctx, this->m_object_no, this->m_extents,
+ this->m_io_context->read_snap().value_or(CEPH_NOSNAP), this->m_trace,
+ m_read_data, ctx);
}
template <typename I>
template <typename I>
void ObjectReadRequest<I>::copyup() {
I *image_ctx = this->m_ictx;
- if (!is_copy_on_read(image_ctx, this->m_snap_id)) {
+ if (!is_copy_on_read(image_ctx, this->m_io_context)) {
this->finish(0);
return;
}
template <typename I>
AbstractObjectWriteRequest<I>::AbstractObjectWriteRequest(
I *ictx, uint64_t object_no, uint64_t object_off, uint64_t len,
- const ::SnapContext &snapc, const char *trace_name,
+ IOContext io_context, const char *trace_name,
const ZTracer::Trace &parent_trace, Context *completion)
- : ObjectRequest<I>(ictx, object_no, CEPH_NOSNAP, trace_name, parent_trace,
+ : ObjectRequest<I>(ictx, object_no, io_context, trace_name, parent_trace,
completion),
- m_object_off(object_off), m_object_len(len), m_snap_seq(snapc.seq.val)
+ m_object_off(object_off), m_object_len(len)
{
- m_snaps.insert(m_snaps.end(), snapc.snaps.begin(), snapc.snaps.end());
-
if (this->m_object_off == 0 &&
this->m_object_len == ictx->get_object_size()) {
m_full_object = true;
this->compute_parent_extents(&m_parent_extents, false);
if (!this->has_parent() ||
- (m_full_object && m_snaps.empty() && !is_post_copyup_write_required())) {
+ (m_full_object &&
+ !this->m_io_context->write_snap_context() &&
+ !is_post_copyup_write_required())) {
m_copyup_enabled = false;
}
}
ldout(image_ctx->cct, 20) << "guarding write" << dendl;
if (m_guarding_migration_write) {
cls_client::assert_snapc_seq(
- &write_op, m_snap_seq, cls::rbd::ASSERT_SNAPC_SEQ_LE_SNAPSET_SEQ);
+ &write_op,
+ (this->m_io_context->write_snap_context() ?
+ this->m_io_context->write_snap_context()->first : 0),
+ cls::rbd::ASSERT_SNAPC_SEQ_LE_SNAPSET_SEQ);
} else {
write_op.assert_exists();
}
image_ctx->rados_api.execute(
{data_object_name(this->m_ictx, this->m_object_no)},
- *image_ctx->get_data_io_context(), std::move(write_op),
+ *this->m_io_context, std::move(write_op),
librbd::asio::util::get_callback_adapter(
[this](int r) { handle_write_object(r); }), nullptr,
(this->m_trace.valid() ? this->m_trace.get_info() : nullptr));
#include "include/int_types.h"
#include "include/buffer.h"
#include "include/rados/librados.hpp"
-#include "common/snap_types.h"
#include "common/zipkin_trace.h"
#include "librbd/ObjectMap.h"
+#include "librbd/Types.h"
#include "librbd/io/Types.h"
#include <map>
public:
static ObjectRequest* create_write(
ImageCtxT *ictx, uint64_t object_no, uint64_t object_off,
- ceph::bufferlist&& data, const ::SnapContext &snapc, int op_flags,
+ ceph::bufferlist&& data, IOContext io_context, int op_flags,
int write_flags, std::optional<uint64_t> assert_version,
const ZTracer::Trace &parent_trace, Context *completion);
static ObjectRequest* create_discard(
ImageCtxT *ictx, uint64_t object_no, uint64_t object_off,
- uint64_t object_len, const ::SnapContext &snapc, int discard_flags,
+ uint64_t object_len, IOContext io_context, int discard_flags,
const ZTracer::Trace &parent_trace, Context *completion);
static ObjectRequest* create_write_same(
ImageCtxT *ictx, uint64_t object_no, uint64_t object_off,
- uint64_t object_len, ceph::bufferlist&& data, const ::SnapContext &snapc,
+ uint64_t object_len, ceph::bufferlist&& data, IOContext io_context,
int op_flags, const ZTracer::Trace &parent_trace, Context *completion);
static ObjectRequest* create_compare_and_write(
ImageCtxT *ictx, uint64_t object_no, uint64_t object_off,
ceph::bufferlist&& cmp_data, ceph::bufferlist&& write_data,
- const ::SnapContext &snapc, uint64_t *mismatch_offset, int op_flags,
+ IOContext io_context, uint64_t *mismatch_offset, int op_flags,
const ZTracer::Trace &parent_trace, Context *completion);
- ObjectRequest(ImageCtxT *ictx, uint64_t objectno, librados::snap_t snap_id,
+ ObjectRequest(ImageCtxT *ictx, uint64_t objectno, IOContext io_context,
const char *trace_name, const ZTracer::Trace &parent_trace,
Context *completion);
virtual ~ObjectRequest() {
ImageCtxT *m_ictx;
uint64_t m_object_no;
- librados::snap_t m_snap_id;
+ IOContext m_io_context;
Context *m_completion;
ZTracer::Trace m_trace;
public:
static ObjectReadRequest* create(
ImageCtxT *ictx, uint64_t objectno, const Extents &extents,
- librados::snap_t snap_id, int op_flags,
- const ZTracer::Trace &parent_trace, ceph::bufferlist* read_data,
- Extents* extent_map, uint64_t* version, Context *completion) {
- return new ObjectReadRequest(ictx, objectno, extents, snap_id, op_flags,
+ IOContext io_context, int op_flags, const ZTracer::Trace &parent_trace,
+ ceph::bufferlist* read_data, Extents* extent_map, uint64_t* version,
+ Context *completion) {
+ return new ObjectReadRequest(ictx, objectno, extents, io_context, op_flags,
parent_trace, read_data, extent_map, version,
completion);
}
ObjectReadRequest(
ImageCtxT *ictx, uint64_t objectno, const Extents &extents,
- librados::snap_t snap_id, int op_flags,
- const ZTracer::Trace &parent_trace, ceph::bufferlist* read_data,
- Extents* extent_map, uint64_t* version, Context *completion);
+ IOContext io_context, int op_flags, const ZTracer::Trace &parent_trace,
+ ceph::bufferlist* read_data, Extents* extent_map, uint64_t* version,
+ Context *completion);
void send() override;
public:
AbstractObjectWriteRequest(
ImageCtxT *ictx, uint64_t object_no, uint64_t object_off, uint64_t len,
- const ::SnapContext &snapc, const char *trace_name,
+ IOContext io_context, const char *trace_name,
const ZTracer::Trace &parent_trace, Context *completion);
virtual bool is_empty_write_op() const {
* @endverbatim
*/
- uint64_t m_snap_seq;
- std::vector<librados::snap_t> m_snaps;
-
Extents m_parent_extents;
bool m_object_may_exist = false;
bool m_copyup_in_progress = false;
public:
ObjectWriteRequest(
ImageCtxT *ictx, uint64_t object_no, uint64_t object_off,
- ceph::bufferlist&& data, const ::SnapContext &snapc, int op_flags,
+ ceph::bufferlist&& data, IOContext io_context, int op_flags,
int write_flags, std::optional<uint64_t> assert_version,
const ZTracer::Trace &parent_trace, Context *completion)
: AbstractObjectWriteRequest<ImageCtxT>(ictx, object_no, object_off,
- data.length(), snapc, "write",
+ data.length(), io_context, "write",
parent_trace, completion),
m_write_data(std::move(data)), m_op_flags(op_flags),
m_write_flags(write_flags), m_assert_version(assert_version) {
public:
ObjectDiscardRequest(
ImageCtxT *ictx, uint64_t object_no, uint64_t object_off,
- uint64_t object_len, const ::SnapContext &snapc, int discard_flags,
+ uint64_t object_len, IOContext io_context, int discard_flags,
const ZTracer::Trace &parent_trace, Context *completion)
: AbstractObjectWriteRequest<ImageCtxT>(ictx, object_no, object_off,
- object_len, snapc, "discard",
+ object_len, io_context, "discard",
parent_trace, completion),
m_discard_flags(discard_flags) {
if (this->m_full_object) {
public:
ObjectWriteSameRequest(
ImageCtxT *ictx, uint64_t object_no, uint64_t object_off,
- uint64_t object_len, ceph::bufferlist&& data, const ::SnapContext &snapc,
+ uint64_t object_len, ceph::bufferlist&& data, IOContext io_context,
int op_flags, const ZTracer::Trace &parent_trace, Context *completion)
: AbstractObjectWriteRequest<ImageCtxT>(ictx, object_no, object_off,
- object_len, snapc, "writesame",
+ object_len, io_context, "writesame",
parent_trace, completion),
m_write_data(std::move(data)), m_op_flags(op_flags) {
}
ObjectCompareAndWriteRequest(
ImageCtxT *ictx, uint64_t object_no, uint64_t object_off,
ceph::bufferlist&& cmp_bl, ceph::bufferlist&& write_bl,
- const ::SnapContext &snapc, uint64_t *mismatch_offset, int op_flags,
+ IOContext io_context, uint64_t *mismatch_offset, int op_flags,
const ZTracer::Trace &parent_trace, Context *completion)
: AbstractObjectWriteRequest<ImageCtxT>(ictx, object_no, object_off,
- cmp_bl.length(), snapc,
+ cmp_bl.length(), io_context,
"compare_and_write", parent_trace,
completion),
m_cmp_bl(std::move(cmp_bl)), m_write_bl(std::move(write_bl)),
// vim: ts=8 sw=2 smarttab
#include "librbd/io/SimpleSchedulerObjectDispatch.h"
+#include "include/neorados/RADOS.hpp"
#include "common/Timer.h"
#include "common/errno.h"
#include "librbd/AsioEngine.h"
template <typename I>
bool SimpleSchedulerObjectDispatch<I>::ObjectRequests::try_delay_request(
- uint64_t object_off, ceph::bufferlist&& data, const ::SnapContext &snapc,
+ uint64_t object_off, ceph::bufferlist&& data, IOContext io_context,
int op_flags, int object_dispatch_flags, Context* on_dispatched) {
if (!m_delayed_requests.empty()) {
- if (snapc.seq != m_snapc.seq || op_flags != m_op_flags ||
- data.length() == 0 || intersects(object_off, data.length())) {
+ if (!m_io_context || *m_io_context != *io_context ||
+ op_flags != m_op_flags || data.length() == 0 ||
+ intersects(object_off, data.length())) {
return false;
}
} else {
- m_snapc = snapc;
+ m_io_context = io_context;
m_op_flags = op_flags;
}
auto req = ObjectDispatchSpec::create_write(
image_ctx, OBJECT_DISPATCH_LAYER_SCHEDULER,
- m_object_no, offset, std::move(merged_requests.data), m_snapc,
+ m_object_no, offset, std::move(merged_requests.data), m_io_context,
m_op_flags, 0, std::nullopt, 0, {}, ctx);
req->object_dispatch_flags = m_object_dispatch_flags;
template <typename I>
bool SimpleSchedulerObjectDispatch<I>::read(
- uint64_t object_no, const Extents &extents, librados::snap_t snap_id,
+ uint64_t object_no, const Extents &extents, IOContext io_context,
int op_flags, const ZTracer::Trace &parent_trace,
ceph::bufferlist* read_data, Extents* extent_map, uint64_t* version,
int* object_dispatch_flags, DispatchResult* dispatch_result,
template <typename I>
bool SimpleSchedulerObjectDispatch<I>::discard(
uint64_t object_no, uint64_t object_off, uint64_t object_len,
- const ::SnapContext &snapc, int discard_flags,
+ IOContext io_context, int discard_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) {
template <typename I>
bool SimpleSchedulerObjectDispatch<I>::write(
uint64_t object_no, uint64_t object_off, ceph::bufferlist&& data,
- const ::SnapContext &snapc, int op_flags, int write_flags,
+ IOContext io_context, int op_flags, int write_flags,
std::optional<uint64_t> assert_version,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, DispatchResult* dispatch_result,
}
std::lock_guard locker{m_lock};
- if (try_delay_write(object_no, object_off, std::move(data), snapc, op_flags,
- *object_dispatch_flags, on_dispatched)) {
+ if (try_delay_write(object_no, object_off, std::move(data), io_context,
+ op_flags, *object_dispatch_flags, on_dispatched)) {
auto dispatch_seq = ++m_dispatch_seq;
m_flush_tracker->start_io(dispatch_seq);
bool SimpleSchedulerObjectDispatch<I>::write_same(
uint64_t object_no, uint64_t object_off, uint64_t object_len,
LightweightBufferExtents&& buffer_extents, ceph::bufferlist&& data,
- const ::SnapContext &snapc, int op_flags,
+ IOContext io_context, int op_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) {
template <typename I>
bool SimpleSchedulerObjectDispatch<I>::compare_and_write(
uint64_t object_no, uint64_t object_off, ceph::bufferlist&& cmp_data,
- ceph::bufferlist&& write_data, const ::SnapContext &snapc, int op_flags,
+ ceph::bufferlist&& write_data, IOContext io_context, int op_flags,
const ZTracer::Trace &parent_trace, uint64_t* mismatch_offset,
int* object_dispatch_flags, uint64_t* journal_tid,
DispatchResult* dispatch_result, Context** on_finish,
template <typename I>
bool SimpleSchedulerObjectDispatch<I>::try_delay_write(
uint64_t object_no, uint64_t object_off, ceph::bufferlist&& data,
- const ::SnapContext &snapc, int op_flags, int object_dispatch_flags,
+ IOContext io_context, int op_flags, int object_dispatch_flags,
Context* on_dispatched) {
ceph_assert(ceph_mutex_is_locked(m_lock));
auto cct = m_image_ctx->cct;
auto &object_requests = it->second;
bool delayed = object_requests->try_delay_request(
- object_off, std::move(data), snapc, op_flags, object_dispatch_flags,
+ object_off, std::move(data), io_context, op_flags, object_dispatch_flags,
on_dispatched);
ldout(cct, 20) << "delayed: " << delayed << dendl;
#define CEPH_LIBRBD_IO_SIMPLE_SCHEDULER_OBJECT_DISPATCH_H
#include "common/ceph_mutex.h"
-#include "common/snap_types.h"
#include "include/interval_set.h"
#include "include/utime.h"
void shut_down(Context* on_finish) override;
bool read(
- uint64_t object_no, const Extents &extents, librados::snap_t snap_id,
+ uint64_t object_no, const Extents &extents, IOContext io_context,
int op_flags, const ZTracer::Trace &parent_trace,
ceph::bufferlist* read_data, Extents* extent_map,
uint64_t* version, int* object_dispatch_flags,
bool discard(
uint64_t object_no, uint64_t object_off, uint64_t object_len,
- const ::SnapContext &snapc, int discard_flags,
+ IOContext io_context, int discard_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) override;
bool write(
uint64_t object_no, uint64_t object_off, ceph::bufferlist&& data,
- const ::SnapContext &snapc, int op_flags, int write_flags,
+ IOContext io_context, int op_flags, int write_flags,
std::optional<uint64_t> assert_version,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, DispatchResult* dispatch_result,
bool write_same(
uint64_t object_no, uint64_t object_off, uint64_t object_len,
LightweightBufferExtents&& buffer_extents, ceph::bufferlist&& data,
- const ::SnapContext &snapc, int op_flags,
+ IOContext io_context, int op_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) override;
bool compare_and_write(
uint64_t object_no, uint64_t object_off, ceph::bufferlist&& cmp_data,
- ceph::bufferlist&& write_data, const ::SnapContext &snapc, int op_flags,
+ ceph::bufferlist&& write_data, IOContext io_context, int op_flags,
const ZTracer::Trace &parent_trace, uint64_t* mismatch_offset,
int* object_dispatch_flags, uint64_t* journal_tid,
DispatchResult* dispatch_result, Context** on_finish,
}
bool try_delay_request(uint64_t object_off, ceph::bufferlist&& data,
- const ::SnapContext &snapc, int op_flags,
+ IOContext io_context, int op_flags,
int object_dispatch_flags, Context* on_dispatched);
void dispatch_delayed_requests(ImageCtxT *image_ctx,
uint64_t m_object_no;
uint64_t m_dispatch_seq = 0;
clock_t::time_point m_dispatch_time;
- SnapContext m_snapc = {0, {}};
+ IOContext m_io_context;
int m_op_flags = 0;
int m_object_dispatch_flags = 0;
std::map<uint64_t, MergedRequests> m_delayed_requests;
std::unique_ptr<LatencyStats> m_latency_stats;
bool try_delay_write(uint64_t object_no, uint64_t object_off,
- ceph::bufferlist&& data, const ::SnapContext &snapc,
+ ceph::bufferlist&& data, IOContext io_context,
int op_flags, int object_dispatch_flags,
Context* on_dispatched);
bool intersects(uint64_t object_no, uint64_t object_off, uint64_t len) const;
template <typename I>
bool ObjectDispatch<I>::discard(
uint64_t object_no, uint64_t object_off, uint64_t object_len,
- const ::SnapContext &snapc, int discard_flags,
+ IOContext io_context, int discard_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, io::DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) {
template <typename I>
bool ObjectDispatch<I>::write(
uint64_t object_no, uint64_t object_off, ceph::bufferlist&& data,
- const ::SnapContext &snapc, int op_flags, int write_flags,
+ IOContext io_context, int op_flags, int write_flags,
std::optional<uint64_t> assert_version,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, io::DispatchResult* dispatch_result,
bool ObjectDispatch<I>::write_same(
uint64_t object_no, uint64_t object_off, uint64_t object_len,
io::LightweightBufferExtents&& buffer_extents, ceph::bufferlist&& data,
- const ::SnapContext &snapc, int op_flags,
+ IOContext io_context, int op_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, io::DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) {
template <typename I>
bool ObjectDispatch<I>::compare_and_write(
uint64_t object_no, uint64_t object_off, ceph::bufferlist&& cmp_data,
- ceph::bufferlist&& write_data, const ::SnapContext &snapc, int op_flags,
+ ceph::bufferlist&& write_data, IOContext io_context, int op_flags,
const ZTracer::Trace &parent_trace, uint64_t* mismatch_offset,
int* object_dispatch_flags, uint64_t* journal_tid,
io::DispatchResult* dispatch_result, Context** on_finish,
#include "include/int_types.h"
#include "include/buffer.h"
#include "include/rados/librados.hpp"
-#include "common/snap_types.h"
#include "common/zipkin_trace.h"
#include "librbd/io/Types.h"
#include "librbd/io/ObjectDispatchInterface.h"
void shut_down(Context* on_finish) override;
bool read(
- uint64_t object_no, const io::Extents &extents, librados::snap_t snap_id,
+ uint64_t object_no, const io::Extents &extents, IOContext io_context,
int op_flags, const ZTracer::Trace &parent_trace,
ceph::bufferlist* read_data, io::Extents* extent_map,
uint64_t* version, int* object_dispatch_flags,
bool discard(
uint64_t object_no, uint64_t object_off, uint64_t object_len,
- const ::SnapContext &snapc, int discard_flags,
+ IOContext io_context, int discard_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, io::DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) override;
bool write(
uint64_t object_no, uint64_t object_off, ceph::bufferlist&& data,
- const ::SnapContext &snapc, int op_flags, int write_flags,
+ IOContext io_context, int op_flags, int write_flags,
std::optional<uint64_t> assert_version,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, io::DispatchResult* dispatch_result,
bool write_same(
uint64_t object_no, uint64_t object_off, uint64_t object_len,
io::LightweightBufferExtents&& buffer_extents, ceph::bufferlist&& data,
- const ::SnapContext &snapc, int op_flags,
+ IOContext io_context, int op_flags,
const ZTracer::Trace &parent_trace, int* object_dispatch_flags,
uint64_t* journal_tid, io::DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) override;
bool compare_and_write(
uint64_t object_no, uint64_t object_off, ceph::bufferlist&& cmp_data,
- ceph::bufferlist&& write_data, const ::SnapContext &snapc, int op_flags,
+ ceph::bufferlist&& write_data, IOContext io_context, int op_flags,
const ZTracer::Trace &parent_trace, uint64_t* mismatch_offset,
int* object_dispatch_flags, uint64_t* journal_tid,
io::DispatchResult* dispatch_result, Context** on_finish,
class C_FlattenObject : public C_AsyncObjectThrottle<I> {
public:
C_FlattenObject(AsyncObjectThrottle<I> &throttle, I *image_ctx,
- ::SnapContext snapc, uint64_t object_no)
- : C_AsyncObjectThrottle<I>(throttle, *image_ctx), m_snapc(snapc),
+ IOContext io_context, uint64_t object_no)
+ : C_AsyncObjectThrottle<I>(throttle, *image_ctx), m_io_context(io_context),
m_object_no(object_no) {
}
bufferlist bl;
auto req = new io::ObjectWriteRequest<I>(&image_ctx, m_object_no, 0,
- std::move(bl), m_snapc, 0, 0,
+ std::move(bl), m_io_context, 0, 0,
std::nullopt, {}, this);
if (!req->has_parent()) {
// stop early if the parent went away - it just means
}
private:
- ::SnapContext m_snapc;
+ IOContext m_io_context;
uint64_t m_object_no;
};
&FlattenRequest<I>::handle_flatten_objects>(this);
typename AsyncObjectThrottle<I>::ContextFactory context_factory(
boost::lambda::bind(boost::lambda::new_ptr<C_FlattenObject<I> >(),
- boost::lambda::_1, &image_ctx, m_snapc, boost::lambda::_2));
+ boost::lambda::_1, &image_ctx, image_ctx.get_data_io_context(),
+ boost::lambda::_2));
AsyncObjectThrottle<I> *throttle = new AsyncObjectThrottle<I>(
this, image_ctx, context_factory, ctx, &m_prog_ctx, 0, m_overlap_objects);
throttle->start_ops(
#define CEPH_LIBRBD_OPERATION_FLATTEN_REQUEST_H
#include "librbd/operation/Request.h"
-#include "common/snap_types.h"
namespace librbd {
{
public:
FlattenRequest(ImageCtxT &image_ctx, Context *on_finish,
- uint64_t overlap_objects, const ::SnapContext &snapc,
- ProgressContext &prog_ctx)
+ uint64_t overlap_objects, ProgressContext &prog_ctx)
: Request<ImageCtxT>(image_ctx, on_finish),
- m_overlap_objects(overlap_objects),
- m_snapc(snapc), m_prog_ctx(prog_ctx) {
+ m_overlap_objects(overlap_objects), m_prog_ctx(prog_ctx) {
}
protected:
*/
uint64_t m_overlap_objects;
- ::SnapContext m_snapc;
ProgressContext &m_prog_ctx;
void flatten_objects();
class C_MigrateObject : public C_AsyncObjectThrottle<I> {
public:
C_MigrateObject(AsyncObjectThrottle<I> &throttle, I *image_ctx,
- ::SnapContext snapc, uint64_t object_no)
- : C_AsyncObjectThrottle<I>(throttle, *image_ctx), m_snapc(snapc),
+ IOContext io_context, uint64_t object_no)
+ : C_AsyncObjectThrottle<I>(throttle, *image_ctx), m_io_context(io_context),
m_object_no(object_no) {
}
}
private:
- ::SnapContext m_snapc;
+ IOContext m_io_context;
uint64_t m_object_no;
io::AsyncOperation *m_async_op = nullptr;
if (is_within_overlap_bounds()) {
bufferlist bl;
auto req = new io::ObjectWriteRequest<I>(&image_ctx, m_object_no, 0,
- std::move(bl), m_snapc, 0, 0,
- std::nullopt, {}, ctx);
+ std::move(bl), m_io_context, 0,
+ 0, std::nullopt, {}, ctx);
ldout(cct, 20) << "copyup object req " << req << ", object_no "
<< m_object_no << dendl;
typename AsyncObjectThrottle<I>::ContextFactory context_factory(
boost::lambda::bind(boost::lambda::new_ptr<C_MigrateObject<I> >(),
- boost::lambda::_1, &image_ctx, image_ctx.snapc, boost::lambda::_2));
+ boost::lambda::_1, &image_ctx, image_ctx.get_data_io_context(),
+ boost::lambda::_2));
AsyncObjectThrottle<I> *throttle = new AsyncObjectThrottle<I>(
this, image_ctx, context_factory, ctx, &m_prog_ctx, 0, overlap_objects);
throttle->start_ops(
#define CEPH_LIBRBD_OPERATION_MIGRATE_REQUEST_H
#include "librbd/operation/Request.h"
-#include "common/snap_types.h"
#include "librbd/Types.h"
namespace librbd {
class C_CopyupObject : public C_AsyncObjectThrottle<I> {
public:
C_CopyupObject(AsyncObjectThrottle<I> &throttle, I *image_ctx,
- ::SnapContext snapc, uint64_t object_no)
- : C_AsyncObjectThrottle<I>(throttle, *image_ctx), m_snapc(snapc),
+ IOContext io_context, uint64_t object_no)
+ : C_AsyncObjectThrottle<I>(throttle, *image_ctx), m_io_context(io_context),
m_object_no(object_no)
{
}
auto object_dispatch_spec = io::ObjectDispatchSpec::create_discard(
&image_ctx, io::OBJECT_DISPATCH_LAYER_NONE, m_object_no, 0,
- image_ctx.layout.object_size, m_snapc,
+ image_ctx.layout.object_size, m_io_context,
io::OBJECT_DISCARD_FLAG_DISABLE_OBJECT_MAP_UPDATE, 0, {}, this);
object_dispatch_spec->send();
return 0;
}
private:
- ::SnapContext m_snapc;
+ IOContext m_io_context;
uint64_t m_object_no;
};
I &image_ctx = this->m_image_ctx;
ceph_assert(ceph_mutex_is_locked(image_ctx.owner_lock));
- ::SnapContext snapc;
+ IOContext io_context;
bool has_snapshots;
uint64_t parent_overlap;
{
std::shared_lock image_locker{image_ctx.image_lock};
- snapc = image_ctx.snapc;
+ io_context = image_ctx.get_data_io_context();
has_snapshots = !image_ctx.snaps.empty();
int r = image_ctx.get_parent_overlap(CEPH_NOSNAP, &parent_overlap);
ceph_assert(r == 0);
Context *ctx = this->create_callback_context();
typename AsyncObjectThrottle<I>::ContextFactory context_factory(
boost::lambda::bind(boost::lambda::new_ptr<C_CopyupObject<I> >(),
- boost::lambda::_1, &image_ctx, snapc, boost::lambda::_2));
+ boost::lambda::_1, &image_ctx, io_context, boost::lambda::_2));
AsyncObjectThrottle<I> *throttle = new AsyncObjectThrottle<I>(
this, image_ctx, context_factory, ctx, &m_prog_ctx, copyup_start,
copyup_end);
<< " length=" << delete_len << dendl;
m_state = STATE_CLEAN_BOUNDARY;
- ::SnapContext snapc;
+ IOContext io_context;
{
std::shared_lock image_locker{image_ctx.image_lock};
- snapc = image_ctx.snapc;
+ io_context = image_ctx.get_data_io_context();
}
// discard the weird boundary
auto object_dispatch_spec = io::ObjectDispatchSpec::create_discard(
&image_ctx, io::OBJECT_DISPATCH_LAYER_NONE, p->objectno, p->offset,
- p->length, snapc, 0, 0, {}, req_comp);
+ p->length, io_context, 0, 0, {}, req_comp);
object_dispatch_spec->send();
}
completion->finish_adding_requests();
}
}
+bool operator ==(const IOContext& lhs, const IOContext& rhs) {
+ auto l = reinterpret_cast<const IOContextImpl*>(&lhs.impl);
+ auto r = reinterpret_cast<const IOContextImpl*>(&rhs.impl);
+ return (l->oloc == r->oloc &&
+ l->snap_seq == r->snap_seq &&
+ l->snapc.seq == r->snapc.seq &&
+ l->snapc.snaps == r->snapc.snaps);
+}
+
+bool operator !=(const IOContext& lhs, const IOContext& rhs) {
+ return !(lhs == rhs);
+}
+
Op::Op() {
static_assert(Op::impl_size >= sizeof(librados::TestObjectOperationImpl*));
auto& o = *reinterpret_cast<librados::TestObjectOperationImpl**>(&impl);
std::string temp_oid("12345");
ceph::bufferlist temp_bl;
- ::SnapContext *temp_snapc = nullptr;
+ IOContext io_context = mock_image_ctx.get_data_io_context();
io::DispatchResult* temp_dispatch_result = nullptr;
io::Extents temp_buffer_extents;
int* temp_op_flags = nullptr;
ZTracer::Trace* temp_trace = nullptr;
io::LightweightBufferExtents buffer_extents;
- ASSERT_EQ(mock_parent_image_cache->discard(0, 0, 0, *temp_snapc, 0, *temp_trace, temp_op_flags,
- temp_journal_tid, temp_dispatch_result, temp_on_finish, temp_on_dispatched), false);
- ASSERT_EQ(mock_parent_image_cache->write(0, 0, std::move(temp_bl), *temp_snapc, 0, 0, std::nullopt,
+ ASSERT_EQ(mock_parent_image_cache->discard(0, 0, 0, io_context, 0,
*temp_trace, temp_op_flags, temp_journal_tid, temp_dispatch_result,
temp_on_finish, temp_on_dispatched), false);
+ ASSERT_EQ(mock_parent_image_cache->write(0, 0, std::move(temp_bl),
+ io_context, 0, 0, std::nullopt, *temp_trace, temp_op_flags,
+ temp_journal_tid, temp_dispatch_result, temp_on_finish,
+ temp_on_dispatched), false);
ASSERT_EQ(mock_parent_image_cache->write_same(0, 0, 0, std::move(buffer_extents),
- std::move(temp_bl), *temp_snapc, 0, *temp_trace, temp_op_flags,
+ std::move(temp_bl), io_context, 0, *temp_trace, temp_op_flags,
temp_journal_tid, temp_dispatch_result, temp_on_finish, temp_on_dispatched), false );
ASSERT_EQ(mock_parent_image_cache->compare_and_write(0, 0, std::move(temp_bl), std::move(temp_bl),
- *temp_snapc, 0, *temp_trace, temp_journal_tid, temp_op_flags, temp_journal_tid,
- temp_dispatch_result, temp_on_finish, temp_on_dispatched), false);
+ io_context, 0, *temp_trace, temp_journal_tid, temp_op_flags,
+ temp_journal_tid, temp_dispatch_result, temp_on_finish,
+ temp_on_dispatched), false);
ASSERT_EQ(mock_parent_image_cache->flush(io::FLUSH_SOURCE_USER, *temp_trace, temp_journal_tid,
temp_dispatch_result, temp_on_finish, temp_on_dispatched), false);
ASSERT_EQ(mock_parent_image_cache->invalidate_cache(nullptr), false);
C_SaferCond on_dispatched;
io::DispatchResult dispatch_result;
ceph::bufferlist read_data;
- mock_parent_image_cache->read(0, {{0, 4096}}, CEPH_NOSNAP, 0, {}, &read_data,
- nullptr, nullptr, nullptr, &dispatch_result,
- nullptr, &on_dispatched);
+ mock_parent_image_cache->read(
+ 0, {{0, 4096}}, mock_image_ctx.get_data_io_context(), 0, {}, &read_data,
+ nullptr, nullptr, nullptr, &dispatch_result, nullptr, &on_dispatched);
ASSERT_EQ(0, on_dispatched.wait());
mock_parent_image_cache->get_cache_client()->close();
C_SaferCond on_dispatched;
io::DispatchResult dispatch_result;
- mock_parent_image_cache->read(0, {{0, 4096}}, CEPH_NOSNAP, 0, {}, nullptr,
- nullptr, nullptr, nullptr, &dispatch_result,
- nullptr, &on_dispatched);
+ mock_parent_image_cache->read(
+ 0, {{0, 4096}}, mock_image_ctx.get_data_io_context(), 0, {}, nullptr,
+ nullptr, nullptr, nullptr, &dispatch_result, nullptr, &on_dispatched);
ASSERT_EQ(0, on_dispatched.wait());
mock_parent_image_cache->get_cache_client()->close();
TEST_F(TestMockCryptoCryptoObjectDispatch, Discard) {
expect_object_write_same();
ASSERT_TRUE(mock_crypto_object_dispatch->discard(
- 0, 0, 4096, mock_image_ctx->snapc, 0, {}, &object_dispatch_flags,
- nullptr, &dispatch_result, &on_finish, on_dispatched));
+ 0, 0, 4096, mock_image_ctx->get_data_io_context(), 0, {},
+ &object_dispatch_flags, nullptr, &dispatch_result, &on_finish,
+ on_dispatched));
ASSERT_EQ(dispatch_result, io::DISPATCH_RESULT_COMPLETE);
ASSERT_EQ(ETIMEDOUT, dispatched_cond.wait_for(0));
TEST_F(TestMockCryptoCryptoObjectDispatch, ReadFail) {
expect_object_read();
ASSERT_TRUE(mock_crypto_object_dispatch->read(
- 0, {{0, 4096}}, CEPH_NOSNAP, 0, {}, &data, &extent_map, nullptr,
- &object_dispatch_flags, &dispatch_result, &on_finish, on_dispatched));
+ 0, {{0, 4096}}, mock_image_ctx->get_data_io_context(), 0, {}, &data,
+ &extent_map, nullptr, &object_dispatch_flags, &dispatch_result,
+ &on_finish, on_dispatched));
ASSERT_EQ(dispatch_result, io::DISPATCH_RESULT_COMPLETE);
ASSERT_NE(on_finish, &finished_cond);
TEST_F(TestMockCryptoCryptoObjectDispatch, Read) {
expect_object_read();
ASSERT_TRUE(mock_crypto_object_dispatch->read(
- 0, {{0, 4096}}, CEPH_NOSNAP, 0, {}, &data, &extent_map, nullptr,
- &object_dispatch_flags, &dispatch_result, &on_finish,
- on_dispatched));
+ 0, {{0, 4096}}, mock_image_ctx->get_data_io_context(), 0, {}, &data,
+ &extent_map, nullptr, &object_dispatch_flags, &dispatch_result,
+ &on_finish, on_dispatched));
ASSERT_EQ(dispatch_result, io::DISPATCH_RESULT_COMPLETE);
ASSERT_NE(on_finish, &finished_cond);
ASSERT_EQ(ETIMEDOUT, dispatched_cond.wait_for(0));
TEST_F(TestMockCryptoCryptoObjectDispatch, Write) {
expect_encrypt();
ASSERT_TRUE(mock_crypto_object_dispatch->write(
- 0, 0, std::move(data), mock_image_ctx->snapc, 0, 0, std::nullopt, {},
- nullptr, nullptr, &dispatch_result, &on_finish, on_dispatched));
+ 0, 0, std::move(data), mock_image_ctx->get_data_io_context(), 0, 0,
+ std::nullopt, {}, nullptr, nullptr, &dispatch_result, &on_finish,
+ on_dispatched));
ASSERT_EQ(dispatch_result, io::DISPATCH_RESULT_CONTINUE);
ASSERT_EQ(on_finish, &finished_cond); // not modified
on_finish->complete(0);
expect_encrypt(2);
ASSERT_TRUE(mock_crypto_object_dispatch->compare_and_write(
0, 0, std::move(cmp_data), std::move(data),
- mock_image_ctx->snapc, 0, {}, nullptr, nullptr, nullptr,
- &dispatch_result, &on_finish, on_dispatched));
+ mock_image_ctx->get_data_io_context(), 0, {}, nullptr, nullptr,
+ nullptr, &dispatch_result, &on_finish, on_dispatched));
ASSERT_EQ(dispatch_result, io::DISPATCH_RESULT_CONTINUE);
ASSERT_EQ(on_finish, &finished_cond); // not modified
on_finish->complete(0);
expect_object_write();
ASSERT_TRUE(mock_crypto_object_dispatch->write_same(
0, 0, 4096, std::move(buffer_extents), std::move(data),
- mock_image_ctx->snapc, 0, {}, nullptr, nullptr, &dispatch_result,
- &on_finish, on_dispatched));
+ mock_image_ctx->get_data_io_context(), 0, {}, nullptr, nullptr,
+ &dispatch_result, &on_finish, on_dispatched));
ASSERT_EQ(dispatch_result, io::DISPATCH_RESULT_COMPLETE);
ASSERT_EQ(ETIMEDOUT, dispatched_cond.wait_for(0));
C_SaferCond ctx;
uint64_t version;
auto req = MockObjectReadRequest::create(
- &mock_image_ctx, 0, {{0, 4096}, {8192, 4096}}, CEPH_NOSNAP, 0, {},
+ &mock_image_ctx, 0, {{0, 4096}, {8192, 4096}},
+ mock_image_ctx.get_data_io_context(), 0, {},
&bl, &extent_map, &version, &ctx);
req->send();
ASSERT_EQ(0, ctx.wait());
C_SaferCond ctx;
auto req = MockObjectReadRequest::create(
&mock_image_ctx, 0,
- {{0, ictx->sparse_read_threshold_bytes}}, CEPH_NOSNAP, 0, {}, &bl,
+ {{0, ictx->sparse_read_threshold_bytes}},
+ mock_image_ctx.get_data_io_context(), 0, {}, &bl,
&extent_map, nullptr, &ctx);
req->send();
ASSERT_EQ(0, ctx.wait());
Extents extent_map;
C_SaferCond ctx;
auto req = MockObjectReadRequest::create(
- &mock_image_ctx, 0, {{0, 4096}}, CEPH_NOSNAP, 0, {}, &bl, &extent_map,
+ &mock_image_ctx, 0, {{0, 4096}},
+ mock_image_ctx.get_data_io_context(), 0, {}, &bl, &extent_map,
nullptr, &ctx);
req->send();
ASSERT_EQ(-EPERM, ctx.wait());
Extents extent_map;
C_SaferCond ctx;
auto req = MockObjectReadRequest::create(
- &mock_image_ctx, 0, {{0, 4096}}, CEPH_NOSNAP, 0, {}, &bl, &extent_map,
+ &mock_image_ctx, 0, {{0, 4096}},
+ mock_image_ctx.get_data_io_context(), 0, {}, &bl, &extent_map,
nullptr, &ctx);
req->send();
ASSERT_EQ(0, ctx.wait());
Extents extent_map;
C_SaferCond ctx;
auto req = MockObjectReadRequest::create(
- &mock_image_ctx, 0, {{0, 4096}}, CEPH_NOSNAP, 0, {}, &bl, &extent_map,
+ &mock_image_ctx, 0, {{0, 4096}},
+ mock_image_ctx.get_data_io_context(), 0, {}, &bl, &extent_map,
nullptr, &ctx);
req->send();
ASSERT_EQ(-EPERM, ctx.wait());
Extents extent_map;
C_SaferCond ctx;
auto req = MockObjectReadRequest::create(
- &mock_image_ctx, 0, {{0, 4096}}, CEPH_NOSNAP, 0, {}, &bl, &extent_map,
+ &mock_image_ctx, 0, {{0, 4096}},
+ mock_image_ctx.get_data_io_context(), 0, {}, &bl, &extent_map,
nullptr, &ctx);
req->send();
ASSERT_EQ(0, ctx.wait());
C_SaferCond ctx;
auto req = MockObjectWriteRequest::create_write(
- &mock_image_ctx, 0, 0, std::move(bl), mock_image_ctx.snapc, 0, 0,
- std::nullopt, {}, &ctx);
+ &mock_image_ctx, 0, 0, std::move(bl), mock_image_ctx.get_data_io_context(),
+ 0, 0, std::nullopt, {}, &ctx);
req->send();
ASSERT_EQ(0, ctx.wait());
}
C_SaferCond ctx;
auto req = MockObjectWriteRequest::create_write(
- &mock_image_ctx, 0, 0, std::move(bl), mock_image_ctx.snapc, 0,
+ &mock_image_ctx, 0, 0, std::move(bl),
+ mock_image_ctx.get_data_io_context(), 0,
OBJECT_WRITE_FLAG_CREATE_EXCLUSIVE, std::nullopt, {}, &ctx);
req->send();
ASSERT_EQ(0, ctx.wait());
C_SaferCond ctx;
auto req = MockObjectWriteRequest::create_write(
- &mock_image_ctx, 0, 0, std::move(bl), mock_image_ctx.snapc, 0,
+ &mock_image_ctx, 0, 0, std::move(bl),
+ mock_image_ctx.get_data_io_context(), 0,
OBJECT_WRITE_FLAG_CREATE_EXCLUSIVE, std::nullopt, {}, &ctx);
req->send();
ASSERT_EQ(-EEXIST, ctx.wait());
C_SaferCond ctx;
auto req = MockObjectWriteRequest::create_write(
- &mock_image_ctx, 0, 0, std::move(bl), mock_image_ctx.snapc, 0, 0,
+ &mock_image_ctx, 0, 0, std::move(bl),
+ mock_image_ctx.get_data_io_context(), 0, 0,
std::nullopt, {}, &ctx);
req->send();
ASSERT_EQ(0, ctx.wait());
C_SaferCond ctx;
auto req = MockObjectWriteRequest::create_write(
- &mock_image_ctx, 0, 0, std::move(bl), mock_image_ctx.snapc, 0, 0,
+ &mock_image_ctx, 0, 0, std::move(bl),
+ mock_image_ctx.get_data_io_context(), 0, 0,
std::make_optional(1), {}, &ctx);
req->send();
ASSERT_EQ(0, ctx.wait());
C_SaferCond ctx;
auto req = MockObjectWriteRequest::create_write(
- &mock_image_ctx, 0, 0, std::move(bl), mock_image_ctx.snapc, 0, 0,
+ &mock_image_ctx, 0, 0, std::move(bl),
+ mock_image_ctx.get_data_io_context(), 0, 0,
std::make_optional(1), {}, &ctx);
req->send();
ASSERT_EQ(-ERANGE, ctx.wait());
C_SaferCond ctx;
auto req = MockObjectWriteRequest::create_write(
- &mock_image_ctx, 0, 0, std::move(bl), mock_image_ctx.snapc, 0, 0,
- std::make_optional(3), {}, &ctx);
+ &mock_image_ctx, 0, 0, std::move(bl),
+ mock_image_ctx.get_data_io_context(), 0, 0, std::make_optional(3),
+ {}, &ctx);
req->send();
ASSERT_EQ(-EOVERFLOW, ctx.wait());
}
C_SaferCond ctx;
auto req = MockObjectWriteRequest::create_write(
- &mock_image_ctx, 0, 0, std::move(bl), mock_image_ctx.snapc, 0, 0,
- std::nullopt, {}, &ctx);
+ &mock_image_ctx, 0, 0, std::move(bl), mock_image_ctx.get_data_io_context(),
+ 0, 0, std::nullopt, {}, &ctx);
req->send();
ASSERT_EQ(0, ctx.wait());
}
C_SaferCond ctx;
auto req = MockObjectWriteRequest::create_write(
- &mock_image_ctx, 0, 0, std::move(bl), mock_image_ctx.snapc, 0, 0,
- std::nullopt, {}, &ctx);
+ &mock_image_ctx, 0, 0, std::move(bl), mock_image_ctx.get_data_io_context(),
+ 0, 0, std::nullopt, {}, &ctx);
req->send();
ASSERT_EQ(0, ctx.wait());
}
C_SaferCond ctx;
auto req = MockObjectWriteRequest::create_write(
- &mock_image_ctx, 0, 0, std::move(bl), mock_image_ctx.snapc, 0, 0,
- std::nullopt, {}, &ctx);
+ &mock_image_ctx, 0, 0, std::move(bl), mock_image_ctx.get_data_io_context(),
+ 0, 0, std::nullopt, {}, &ctx);
req->send();
ASSERT_EQ(-EPERM, ctx.wait());
}
C_SaferCond ctx;
auto req = MockObjectWriteRequest::create_write(
- &mock_image_ctx, 0, 0, std::move(bl), mock_image_ctx.snapc, 0, 0,
- std::nullopt, {}, &ctx);
+ &mock_image_ctx, 0, 0, std::move(bl), mock_image_ctx.get_data_io_context(),
+ 0, 0, std::nullopt, {}, &ctx);
req->send();
ASSERT_EQ(0, ctx.wait());
}
C_SaferCond ctx;
auto req = MockObjectWriteRequest::create_write(
- &mock_image_ctx, 0, 0, std::move(bl), mock_image_ctx.snapc, 0, 0,
- std::nullopt, {}, &ctx);
+ &mock_image_ctx, 0, 0, std::move(bl), mock_image_ctx.get_data_io_context(),
+ 0, 0, std::nullopt, {}, &ctx);
req->send();
ASSERT_EQ(0, ctx.wait());
}
C_SaferCond ctx;
auto req = MockObjectWriteRequest::create_write(
- &mock_image_ctx, 0, 0, std::move(bl), mock_image_ctx.snapc, 0, 0,
- std::nullopt, {}, &ctx);
+ &mock_image_ctx, 0, 0, std::move(bl), mock_image_ctx.get_data_io_context(),
+ 0, 0, std::nullopt, {}, &ctx);
req->send();
ASSERT_EQ(0, ctx.wait());
}
C_SaferCond ctx;
auto req = MockObjectWriteRequest::create_write(
- &mock_image_ctx, 0, 0, std::move(bl), mock_image_ctx.snapc, 0, 0,
- std::nullopt, {}, &ctx);
+ &mock_image_ctx, 0, 0, std::move(bl), mock_image_ctx.get_data_io_context(),
+ 0, 0, std::nullopt, {}, &ctx);
req->send();
ASSERT_EQ(-EPERM, ctx.wait());
}
C_SaferCond ctx;
auto req = MockObjectDiscardRequest::create_discard(
&mock_image_ctx, 0, 0, mock_image_ctx.get_object_size(),
- mock_image_ctx.snapc, 0, {}, &ctx);
+ mock_image_ctx.get_data_io_context(), 0, {}, &ctx);
req->send();
ASSERT_EQ(0, ctx.wait());
}
C_SaferCond ctx;
auto req = MockObjectDiscardRequest::create_discard(
&mock_image_ctx, 0, 0, mock_image_ctx.get_object_size(),
- mock_image_ctx.snapc, OBJECT_DISCARD_FLAG_DISABLE_CLONE_REMOVE, {}, &ctx);
+ mock_image_ctx.get_data_io_context(),
+ OBJECT_DISCARD_FLAG_DISABLE_CLONE_REMOVE, {}, &ctx);
req->send();
ASSERT_EQ(0, ctx.wait());
}
C_SaferCond ctx;
auto req = MockObjectDiscardRequest::create_discard(
&mock_image_ctx, 0, 0, mock_image_ctx.get_object_size(),
- mock_image_ctx.snapc, OBJECT_DISCARD_FLAG_DISABLE_CLONE_REMOVE, {}, &ctx);
+ mock_image_ctx.get_data_io_context(),
+ OBJECT_DISCARD_FLAG_DISABLE_CLONE_REMOVE, {}, &ctx);
req->send();
ASSERT_EQ(0, ctx.wait());
}
C_SaferCond ctx;
auto req = MockObjectDiscardRequest::create_discard(
&mock_image_ctx, 0, 1, mock_image_ctx.get_object_size() - 1,
- mock_image_ctx.snapc, 0, {}, &ctx);
+ mock_image_ctx.get_data_io_context(), 0, {}, &ctx);
req->send();
ASSERT_EQ(0, ctx.wait());
}
C_SaferCond ctx;
auto req = MockObjectDiscardRequest::create_discard(
- &mock_image_ctx, 0, 1, 1, mock_image_ctx.snapc, 0, {}, &ctx);
+ &mock_image_ctx, 0, 1, 1, mock_image_ctx.get_data_io_context(), 0, {},
+ &ctx);
req->send();
ASSERT_EQ(0, ctx.wait());
}
C_SaferCond ctx;
auto req = MockObjectDiscardRequest::create_discard(
&mock_image_ctx, 0, 0, mock_image_ctx.get_object_size(),
- mock_image_ctx.snapc,
+ mock_image_ctx.get_data_io_context(),
OBJECT_DISCARD_FLAG_DISABLE_CLONE_REMOVE |
OBJECT_DISCARD_FLAG_DISABLE_OBJECT_MAP_UPDATE, {}, &ctx);
req->send();
C_SaferCond ctx;
auto req = MockObjectDiscardRequest::create_discard(
&mock_image_ctx, 0, 0, mock_image_ctx.get_object_size(),
- mock_image_ctx.snapc,
+ mock_image_ctx.get_data_io_context(),
OBJECT_DISCARD_FLAG_DISABLE_CLONE_REMOVE |
OBJECT_DISCARD_FLAG_DISABLE_OBJECT_MAP_UPDATE, {},
&ctx);
C_SaferCond ctx;
auto req = MockObjectWriteSameRequest::create_write_same(
- &mock_image_ctx, 0, 0, 4096, std::move(bl), mock_image_ctx.snapc, 0, {}, &ctx);
+ &mock_image_ctx, 0, 0, 4096, std::move(bl),
+ mock_image_ctx.get_data_io_context(), 0, {}, &ctx);
req->send();
ASSERT_EQ(0, ctx.wait());
}
uint64_t mismatch_offset;
auto req = MockObjectWriteSameRequest::create_compare_and_write(
&mock_image_ctx, 0, 0, std::move(cmp_bl), std::move(bl),
- mock_image_ctx.snapc, &mismatch_offset, 0, {}, &ctx);
+ mock_image_ctx.get_data_io_context(), &mismatch_offset, 0, {}, &ctx);
req->send();
ASSERT_EQ(0, ctx.wait());
}
uint64_t mismatch_offset;
auto req = MockObjectWriteSameRequest::create_compare_and_write(
&mock_image_ctx, 0, 0, std::move(cmp_bl), std::move(bl),
- mock_image_ctx.snapc, &mismatch_offset, 0, {}, &ctx);
+ mock_image_ctx.get_data_io_context(), &mismatch_offset, 0, {}, &ctx);
req->send();
ASSERT_EQ(0, ctx.wait());
}
uint64_t mismatch_offset;
auto req = MockObjectWriteSameRequest::create_compare_and_write(
&mock_image_ctx, 0, 0, std::move(cmp_bl), std::move(bl),
- mock_image_ctx.snapc, &mismatch_offset, 0, {}, &ctx);
+ mock_image_ctx.get_data_io_context(), &mismatch_offset, 0, {}, &ctx);
req->send();
ASSERT_EQ(0, ctx.wait());
}
uint64_t mismatch_offset;
auto req = MockObjectWriteSameRequest::create_compare_and_write(
&mock_image_ctx, 0, 0, std::move(cmp_bl), std::move(bl),
- mock_image_ctx.snapc, &mismatch_offset, 0, {}, &ctx);
+ mock_image_ctx.get_data_io_context(), &mismatch_offset, 0, {}, &ctx);
req->send();
ASSERT_EQ(-EILSEQ, ctx.wait());
ASSERT_EQ(1ULL, mismatch_offset);
C_SaferCond ctx;
auto req = MockObjectWriteRequest::create_write(
- &mock_image_ctx, 0, 0, std::move(bl), mock_image_ctx.snapc, 0, 0,
- std::nullopt, {}, &ctx);
+ &mock_image_ctx, 0, 0, std::move(bl), mock_image_ctx.get_data_io_context(),
+ 0, 0, std::nullopt, {}, &ctx);
req->send();
ASSERT_EQ(-EBLOCKLISTED, ctx.wait());
}
C_SaferCond cond;
Context *on_finish = &cond;
ASSERT_FALSE(mock_simple_scheduler_object_dispatch.read(
- 0, {{0, 4096}}, CEPH_NOSNAP, 0, {}, nullptr, nullptr, nullptr, nullptr,
- nullptr, &on_finish, nullptr));
+ 0, {{0, 4096}}, mock_image_ctx.get_data_io_context(), 0, {}, nullptr,
+ nullptr, nullptr, nullptr, nullptr, &on_finish, nullptr));
ASSERT_EQ(on_finish, &cond); // not modified
on_finish->complete(0);
ASSERT_EQ(0, cond.wait());
C_SaferCond cond;
Context *on_finish = &cond;
ASSERT_FALSE(mock_simple_scheduler_object_dispatch.discard(
- 0, 0, 4096, mock_image_ctx.snapc, 0, {}, nullptr, nullptr, nullptr,
- &on_finish, nullptr));
+ 0, 0, 4096, mock_image_ctx.get_data_io_context(), 0, {}, nullptr, nullptr,
+ nullptr, &on_finish, nullptr));
ASSERT_NE(on_finish, &cond);
on_finish->complete(0);
ASSERT_EQ(0, cond.wait());
C_SaferCond cond;
Context *on_finish = &cond;
ASSERT_FALSE(mock_simple_scheduler_object_dispatch.write(
- 0, 0, std::move(data), mock_image_ctx.snapc, 0, 0, std::nullopt, {},
- &object_dispatch_flags, nullptr, nullptr, &on_finish, nullptr));
+ 0, 0, std::move(data), mock_image_ctx.get_data_io_context(), 0, 0,
+ std::nullopt, {}, &object_dispatch_flags, nullptr, nullptr,
+ &on_finish, nullptr));
ASSERT_NE(on_finish, &cond);
on_finish->complete(0);
ASSERT_EQ(0, cond.wait());
Context *on_finish = &cond;
ASSERT_FALSE(mock_simple_scheduler_object_dispatch.write_same(
0, 0, 4096, std::move(buffer_extents), std::move(data),
- mock_image_ctx.snapc, 0, {}, nullptr, nullptr, nullptr, &on_finish,
- nullptr));
+ mock_image_ctx.get_data_io_context(), 0, {}, nullptr, nullptr, nullptr,
+ &on_finish, nullptr));
ASSERT_NE(on_finish, &cond);
on_finish->complete(0);
ASSERT_EQ(0, cond.wait());
C_SaferCond cond;
Context *on_finish = &cond;
ASSERT_FALSE(mock_simple_scheduler_object_dispatch.compare_and_write(
- 0, 0, std::move(cmp_data), std::move(write_data), mock_image_ctx.snapc, 0,
- {}, nullptr, nullptr, nullptr, nullptr, &on_finish, nullptr));
+ 0, 0, std::move(cmp_data), std::move(write_data),
+ mock_image_ctx.get_data_io_context(), 0, {}, nullptr, nullptr, nullptr,
+ nullptr, &on_finish, nullptr));
ASSERT_NE(on_finish, &cond);
on_finish->complete(0);
ASSERT_EQ(0, cond.wait());
C_SaferCond cond1;
Context *on_finish1 = &cond1;
ASSERT_FALSE(mock_simple_scheduler_object_dispatch.write(
- 0, 0, std::move(data), mock_image_ctx.snapc, 0, 0, std::nullopt, {},
- &object_dispatch_flags, nullptr, nullptr, &on_finish1, nullptr));
+ 0, 0, std::move(data), mock_image_ctx.get_data_io_context(), 0, 0,
+ std::nullopt, {}, &object_dispatch_flags, nullptr, nullptr, &on_finish1,
+ nullptr));
ASSERT_NE(on_finish1, &cond1);
Context *timer_task = nullptr;
Context *on_finish2 = &cond2;
C_SaferCond on_dispatched;
ASSERT_TRUE(mock_simple_scheduler_object_dispatch.write(
- 0, 0, std::move(data), mock_image_ctx.snapc, 0, 0, std::nullopt, {},
- &object_dispatch_flags, nullptr, &dispatch_result, &on_finish2,
- &on_dispatched));
+ 0, 0, std::move(data), mock_image_ctx.get_data_io_context(), 0, 0,
+ std::nullopt, {}, &object_dispatch_flags, nullptr, &dispatch_result,
+ &on_finish2, &on_dispatched));
ASSERT_EQ(dispatch_result, io::DISPATCH_RESULT_COMPLETE);
ASSERT_NE(on_finish2, &cond2);
ASSERT_NE(timer_task, nullptr);
C_SaferCond cond1;
Context *on_finish1 = &cond1;
ASSERT_FALSE(mock_simple_scheduler_object_dispatch.write(
- 0, 0, std::move(data), mock_image_ctx.snapc, 0, 0, std::nullopt, {},
- &object_dispatch_flags, nullptr, nullptr, &on_finish1, nullptr));
+ 0, 0, std::move(data), mock_image_ctx.get_data_io_context(), 0, 0,
+ std::nullopt, {}, &object_dispatch_flags, nullptr, nullptr, &on_finish1,
+ nullptr));
ASSERT_NE(on_finish1, &cond1);
Context *timer_task = nullptr;
Context *on_finish2 = &cond2;
C_SaferCond on_dispatched;
ASSERT_TRUE(mock_simple_scheduler_object_dispatch.write(
- 0, 0, std::move(data), mock_image_ctx.snapc, 0, 0, std::nullopt, {},
- &object_dispatch_flags, nullptr, &dispatch_result, &on_finish2,
- &on_dispatched));
+ 0, 0, std::move(data), mock_image_ctx.get_data_io_context(), 0, 0,
+ std::nullopt, {}, &object_dispatch_flags, nullptr, &dispatch_result,
+ &on_finish2, &on_dispatched));
ASSERT_EQ(dispatch_result, io::DISPATCH_RESULT_COMPLETE);
ASSERT_NE(on_finish2, &cond2);
ASSERT_NE(timer_task, nullptr);
C_SaferCond cond1;
Context *on_finish1 = &cond1;
ASSERT_FALSE(mock_simple_scheduler_object_dispatch.write(
- 0, 0, std::move(data), mock_image_ctx.snapc, 0, 0, std::nullopt, {},
- &object_dispatch_flags, nullptr, nullptr, &on_finish1, nullptr));
+ 0, 0, std::move(data), mock_image_ctx.get_data_io_context(), 0, 0,
+ std::nullopt, {}, &object_dispatch_flags, nullptr, nullptr, &on_finish1,
+ nullptr));
ASSERT_NE(on_finish1, &cond1);
Context *timer_task = nullptr;
Context *on_finish2 = &cond2;
C_SaferCond on_dispatched2;
ASSERT_TRUE(mock_simple_scheduler_object_dispatch.write(
- 0, object_off, std::move(data), mock_image_ctx.snapc, 0, 0, std::nullopt,
- {}, &object_dispatch_flags, nullptr, &dispatch_result, &on_finish2,
- &on_dispatched2));
+ 0, object_off, std::move(data), mock_image_ctx.get_data_io_context(), 0,
+ 0, std::nullopt, {}, &object_dispatch_flags, nullptr, &dispatch_result,
+ &on_finish2, &on_dispatched2));
ASSERT_EQ(dispatch_result, io::DISPATCH_RESULT_COMPLETE);
ASSERT_NE(on_finish2, &cond2);
ASSERT_NE(timer_task, nullptr);
Context *on_finish3 = &cond3;
C_SaferCond on_dispatched3;
ASSERT_TRUE(mock_simple_scheduler_object_dispatch.write(
- 0, object_off, std::move(data), mock_image_ctx.snapc, 0, 0, std::nullopt,
- {}, &object_dispatch_flags, nullptr, &dispatch_result, &on_finish3,
- &on_dispatched3));
+ 0, object_off, std::move(data), mock_image_ctx.get_data_io_context(), 0,
+ 0, std::nullopt, {}, &object_dispatch_flags, nullptr, &dispatch_result,
+ &on_finish3, &on_dispatched3));
ASSERT_EQ(dispatch_result, io::DISPATCH_RESULT_COMPLETE);
ASSERT_NE(on_finish3, &cond3);
Context *on_finish4 = &cond4;
C_SaferCond on_dispatched4;
ASSERT_TRUE(mock_simple_scheduler_object_dispatch.write(
- 0, object_off, std::move(data), mock_image_ctx.snapc, 0, 0, std::nullopt,
- {},&object_dispatch_flags, nullptr, &dispatch_result, &on_finish4,
- &on_dispatched4));
+ 0, object_off, std::move(data), mock_image_ctx.get_data_io_context(), 0,
+ 0, std::nullopt, {},&object_dispatch_flags, nullptr, &dispatch_result,
+ &on_finish4, &on_dispatched4));
ASSERT_EQ(dispatch_result, io::DISPATCH_RESULT_COMPLETE);
ASSERT_NE(on_finish4, &cond4);
Context *on_finish5 = &cond5;
C_SaferCond on_dispatched5;
ASSERT_TRUE(mock_simple_scheduler_object_dispatch.write(
- 0, object_off, std::move(data), mock_image_ctx.snapc, 0, 0, std::nullopt,
- {}, &object_dispatch_flags, nullptr, &dispatch_result, &on_finish5,
- &on_dispatched5));
+ 0, object_off, std::move(data), mock_image_ctx.get_data_io_context(), 0,
+ 0, std::nullopt, {}, &object_dispatch_flags, nullptr, &dispatch_result,
+ &on_finish5, &on_dispatched5));
ASSERT_EQ(dispatch_result, io::DISPATCH_RESULT_COMPLETE);
ASSERT_NE(on_finish5, &cond5);
Context *on_finish6 = &cond6;
C_SaferCond on_dispatched6;
ASSERT_TRUE(mock_simple_scheduler_object_dispatch.write(
- 0, object_off, std::move(data), mock_image_ctx.snapc, 0, 0, std::nullopt,
- {}, &object_dispatch_flags, nullptr, &dispatch_result, &on_finish6,
- &on_dispatched6));
+ 0, object_off, std::move(data), mock_image_ctx.get_data_io_context(), 0,
+ 0, std::nullopt, {}, &object_dispatch_flags, nullptr, &dispatch_result,
+ &on_finish6, &on_dispatched6));
ASSERT_EQ(dispatch_result, io::DISPATCH_RESULT_COMPLETE);
ASSERT_NE(on_finish6, &cond6);
C_SaferCond cond1;
Context *on_finish1 = &cond1;
ASSERT_FALSE(mock_simple_scheduler_object_dispatch.write(
- 0, 0, std::move(data), mock_image_ctx.snapc, 0, 0, std::nullopt, {},
- &object_dispatch_flags, nullptr, nullptr, &on_finish1, nullptr));
+ 0, 0, std::move(data), mock_image_ctx.get_data_io_context(), 0, 0,
+ std::nullopt, {}, &object_dispatch_flags, nullptr, nullptr, &on_finish1,
+ nullptr));
ASSERT_NE(on_finish1, &cond1);
Context *timer_task = nullptr;
Context *on_finish2 = &cond2;
C_SaferCond on_dispatched2;
ASSERT_TRUE(mock_simple_scheduler_object_dispatch.write(
- 0, object_off, std::move(data), mock_image_ctx.snapc, 0, 0, std::nullopt,
- {}, &object_dispatch_flags, nullptr, &dispatch_result, &on_finish2,
- &on_dispatched2));
+ 0, object_off, std::move(data), mock_image_ctx.get_data_io_context(), 0,
+ 0, std::nullopt, {}, &object_dispatch_flags, nullptr, &dispatch_result,
+ &on_finish2, &on_dispatched2));
ASSERT_EQ(dispatch_result, io::DISPATCH_RESULT_COMPLETE);
ASSERT_NE(on_finish2, &cond2);
ASSERT_NE(timer_task, nullptr);
C_SaferCond cond3;
Context *on_finish3 = &cond3;
ASSERT_FALSE(mock_simple_scheduler_object_dispatch.write(
- 0, object_off, std::move(data), mock_image_ctx.snapc, 0, 0, std::nullopt,
- {}, &object_dispatch_flags, nullptr, &dispatch_result, &on_finish3,
- nullptr));
+ 0, object_off, std::move(data), mock_image_ctx.get_data_io_context(), 0,
+ 0, std::nullopt, {}, &object_dispatch_flags, nullptr, &dispatch_result,
+ &on_finish3, nullptr));
ASSERT_NE(on_finish3, &cond3);
on_finish1->complete(0);
C_SaferCond cond1;
Context *on_finish1 = &cond1;
ASSERT_FALSE(mock_simple_scheduler_object_dispatch.write(
- 0, 0, std::move(data), mock_image_ctx.snapc, 0, 0, std::nullopt, {},
- &object_dispatch_flags, nullptr, nullptr, &on_finish1, nullptr));
+ 0, 0, std::move(data), mock_image_ctx.get_data_io_context(), 0, 0,
+ std::nullopt, {}, &object_dispatch_flags, nullptr, nullptr, &on_finish1,
+ nullptr));
ASSERT_NE(on_finish1, &cond1);
// write (2) 0~10 (delayed)
Context *on_finish2 = &cond2;
C_SaferCond on_dispatched2;
ASSERT_TRUE(mock_simple_scheduler_object_dispatch.write(
- 0, object_off, std::move(data), mock_image_ctx.snapc, 0, 0, std::nullopt,
- {}, &object_dispatch_flags, nullptr, &dispatch_result, &on_finish2,
- &on_dispatched2));
+ 0, object_off, std::move(data), mock_image_ctx.get_data_io_context(), 0,
+ 0, std::nullopt, {}, &object_dispatch_flags, nullptr, &dispatch_result,
+ &on_finish2, &on_dispatched2));
ASSERT_EQ(dispatch_result, io::DISPATCH_RESULT_COMPLETE);
ASSERT_NE(on_finish2, &cond2);
ASSERT_NE(timer_task, nullptr);
Context *on_finish3 = &cond3;
C_SaferCond on_dispatched3;
ASSERT_TRUE(mock_simple_scheduler_object_dispatch.write(
- 0, object_off, std::move(data), mock_image_ctx.snapc, 0, 0, std::nullopt,
- {}, &object_dispatch_flags, nullptr, &dispatch_result, &on_finish3,
- &on_dispatched3));
+ 0, object_off, std::move(data), mock_image_ctx.get_data_io_context(), 0,
+ 0, std::nullopt, {}, &object_dispatch_flags, nullptr, &dispatch_result,
+ &on_finish3, &on_dispatched3));
ASSERT_NE(on_finish3, &cond3);
// discard (1) (non-seq io)
C_SaferCond cond4;
Context *on_finish4 = &cond4;
ASSERT_FALSE(mock_simple_scheduler_object_dispatch.discard(
- 0, 4096, 4096, mock_image_ctx.snapc, 0, {}, nullptr, nullptr, nullptr,
- &on_finish4, nullptr));
+ 0, 4096, 4096, mock_image_ctx.get_data_io_context(), 0, {}, nullptr,
+ nullptr, nullptr, &on_finish4, nullptr));
ASSERT_NE(on_finish4, &cond4);
ASSERT_EQ(0, on_dispatched2.wait());
ASSERT_EQ(0, on_dispatched3.wait());
Context *on_finish5 = &cond5;
C_SaferCond on_dispatched5;
ASSERT_TRUE(mock_simple_scheduler_object_dispatch.write(
- 0, object_off, std::move(data), mock_image_ctx.snapc, 0, 0, std::nullopt,
- {}, &object_dispatch_flags, nullptr, &dispatch_result, &on_finish5,
- &on_dispatched5));
+ 0, object_off, std::move(data), mock_image_ctx.get_data_io_context(), 0,
+ 0, std::nullopt, {}, &object_dispatch_flags, nullptr, &dispatch_result,
+ &on_finish5, &on_dispatched5));
ASSERT_NE(on_finish5, &cond5);
ASSERT_NE(timer_task, nullptr);
C_SaferCond cond6;
Context *on_finish6 = &cond6;
ASSERT_FALSE(mock_simple_scheduler_object_dispatch.discard(
- 0, 4096, 4096, mock_image_ctx.snapc, 0, {}, nullptr, nullptr, nullptr,
- &on_finish6, nullptr));
+ 0, 4096, 4096, mock_image_ctx.get_data_io_context(), 0, {}, nullptr,
+ nullptr, nullptr, &on_finish6, nullptr));
ASSERT_NE(on_finish6, &cond6);
ASSERT_EQ(0, on_dispatched5.wait());
Context *on_finish7 = &cond7;
C_SaferCond on_dispatched7;
ASSERT_TRUE(mock_simple_scheduler_object_dispatch.write(
- 0, object_off, std::move(data), mock_image_ctx.snapc, 0, 0, std::nullopt,
- {}, &object_dispatch_flags, nullptr, &dispatch_result, &on_finish7,
- &on_dispatched7));
+ 0, object_off, std::move(data), mock_image_ctx.get_data_io_context(), 0,
+ 0, std::nullopt, {}, &object_dispatch_flags, nullptr, &dispatch_result,
+ &on_finish7, &on_dispatched7));
ASSERT_NE(on_finish7, &cond7);
ASSERT_NE(timer_task, nullptr);
C_SaferCond cond1;
Context *on_finish1 = &cond1;
ASSERT_FALSE(mock_simple_scheduler_object_dispatch.write(
- object_no, 0, std::move(data), mock_image_ctx.snapc, 0, 0, std::nullopt,
- {}, &object_dispatch_flags, nullptr, nullptr, &on_finish1, nullptr));
+ object_no, 0, std::move(data), mock_image_ctx.get_data_io_context(), 0, 0,
+ std::nullopt, {}, &object_dispatch_flags, nullptr, nullptr, &on_finish1,
+ nullptr));
ASSERT_NE(on_finish1, &cond1);
Context *timer_task = nullptr;
Context *on_finish2 = &cond2;
C_SaferCond on_dispatched2;
ASSERT_TRUE(mock_simple_scheduler_object_dispatch.write(
- object_no, 0, std::move(data), mock_image_ctx.snapc, 0, 0, std::nullopt,
- {}, &object_dispatch_flags, nullptr, &dispatch_result, &on_finish2,
- &on_dispatched2));
+ object_no, 0, std::move(data), mock_image_ctx.get_data_io_context(), 0, 0,
+ std::nullopt, {}, &object_dispatch_flags, nullptr, &dispatch_result,
+ &on_finish2, &on_dispatched2));
ASSERT_EQ(dispatch_result, io::DISPATCH_RESULT_COMPLETE);
ASSERT_NE(on_finish2, &cond2);
ASSERT_NE(timer_task, nullptr);
C_SaferCond cond3;
Context *on_finish3 = &cond3;
ASSERT_FALSE(mock_simple_scheduler_object_dispatch.write(
- object_no, 0, std::move(data), mock_image_ctx.snapc, 0, 0, std::nullopt,
- {}, &object_dispatch_flags, nullptr, nullptr, &on_finish3, nullptr));
+ object_no, 0, std::move(data), mock_image_ctx.get_data_io_context(), 0, 0,
+ std::nullopt, {}, &object_dispatch_flags, nullptr, nullptr, &on_finish3,
+ nullptr));
ASSERT_NE(on_finish3, &cond3);
data.clear();
Context *on_finish4 = &cond4;
C_SaferCond on_dispatched4;
ASSERT_TRUE(mock_simple_scheduler_object_dispatch.write(
- object_no, 0, std::move(data), mock_image_ctx.snapc, 0, 0, std::nullopt,
- {}, &object_dispatch_flags, nullptr, &dispatch_result, &on_finish4,
- &on_dispatched4));
+ object_no, 0, std::move(data), mock_image_ctx.get_data_io_context(), 0, 0,
+ std::nullopt, {}, &object_dispatch_flags, nullptr, &dispatch_result,
+ &on_finish4, &on_dispatched4));
ASSERT_EQ(dispatch_result, io::DISPATCH_RESULT_COMPLETE);
ASSERT_NE(on_finish4, &cond4);
C_SaferCond cond1;
Context *on_finish1 = &cond1;
ASSERT_FALSE(mock_simple_scheduler_object_dispatch.write(
- 0, 0, std::move(data), mock_image_ctx.snapc, 0, 0, std::nullopt, {},
- &object_dispatch_flags, nullptr, nullptr, &on_finish1, nullptr));
+ 0, 0, std::move(data), mock_image_ctx.get_data_io_context(), 0, 0,
+ std::nullopt, {}, &object_dispatch_flags, nullptr, nullptr, &on_finish1,
+ nullptr));
ASSERT_NE(on_finish1, &cond1);
Context *timer_task = nullptr;
Context *on_finish2 = &cond2;
C_SaferCond on_dispatched;
ASSERT_TRUE(mock_simple_scheduler_object_dispatch.write(
- 0, 0, std::move(data), mock_image_ctx.snapc, 0, 0, std::nullopt, {},
- &object_dispatch_flags, nullptr, &dispatch_result, &on_finish2,
- &on_dispatched));
+ 0, 0, std::move(data), mock_image_ctx.get_data_io_context(), 0, 0,
+ std::nullopt, {}, &object_dispatch_flags, nullptr, &dispatch_result,
+ &on_finish2, &on_dispatched));
ASSERT_EQ(dispatch_result, io::DISPATCH_RESULT_COMPLETE);
ASSERT_NE(on_finish2, &cond2);
ASSERT_NE(timer_task, nullptr);
IOContext MockImageCtx::get_data_io_context() {
auto ctx = std::make_shared<neorados::IOContext>(
data_ctx.get_id(), data_ctx.get_namespace());
- ctx->read_snap(snap_id);
- ctx->write_snap_context(
- {{snapc.seq, {snapc.snaps.begin(), snapc.snaps.end()}}});
+ if (snap_id != CEPH_NOSNAP) {
+ ctx->read_snap(snap_id);
+ }
+ if (!snapc.snaps.empty()) {
+ ctx->write_snap_context(
+ {{snapc.seq, {snapc.snaps.begin(), snapc.snaps.end()}}});
+ }
return ctx;
}
MOCK_METHOD1(shut_down, void(Context*));
MOCK_METHOD8(execute_read,
- bool(uint64_t, const Extents&, librados::snap_t,
+ bool(uint64_t, const Extents&, IOContext io_context,
ceph::bufferlist*, Extents*, uint64_t*,
DispatchResult*, Context*));
bool read(
- uint64_t object_no, const Extents& extents, librados::snap_t snap_id,
+ uint64_t object_no, const Extents& extents, IOContext io_context,
int op_flags, const ZTracer::Trace& parent_trace,
ceph::bufferlist* read_data, Extents* extent_map, uint64_t* version,
int* dispatch_flags, DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) {
- return execute_read(object_no, extents, snap_id, read_data, extent_map,
+ return execute_read(object_no, extents, io_context, read_data, extent_map,
version, dispatch_result, on_dispatched);
}
MOCK_METHOD9(execute_discard,
- bool(uint64_t, uint64_t, uint64_t, const ::SnapContext &, int,
+ bool(uint64_t, uint64_t, uint64_t, IOContext, int,
int*, uint64_t*, DispatchResult*, Context*));
bool discard(
uint64_t object_no, uint64_t object_off, uint64_t object_len,
- const ::SnapContext &snapc, int discard_flags,
+ IOContext io_context, int discard_flags,
const ZTracer::Trace &parent_trace, int* dispatch_flags,
uint64_t* journal_tid, DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) {
- return execute_discard(object_no, object_off, object_len, snapc,
+ return execute_discard(object_no, object_off, object_len, io_context,
discard_flags, dispatch_flags, journal_tid,
dispatch_result, on_dispatched);
}
MOCK_METHOD10(execute_write,
bool(uint64_t, uint64_t, const ceph::bufferlist&,
- const ::SnapContext &, int, std::optional<uint64_t>, int*,
+ IOContext, int, std::optional<uint64_t>, int*,
uint64_t*, DispatchResult*, Context *));
bool write(
uint64_t object_no, uint64_t object_off, ceph::bufferlist&& data,
- const ::SnapContext &snapc, int op_flags, int write_flags,
+ IOContext io_context, int op_flags, int write_flags,
std::optional<uint64_t> assert_version,
const ZTracer::Trace &parent_trace, int* dispatch_flags,
uint64_t* journal_tid, DispatchResult* dispatch_result,
Context** on_finish, Context* on_dispatched) override {
- return execute_write(object_no, object_off, data, snapc, write_flags,
+ return execute_write(object_no, object_off, data, io_context, write_flags,
assert_version, dispatch_flags, journal_tid,
dispatch_result, on_dispatched);
}
MOCK_METHOD10(execute_write_same,
bool(uint64_t, uint64_t, uint64_t,
const LightweightBufferExtents&,
- const ceph::bufferlist&, const ::SnapContext &, int*,
+ const ceph::bufferlist&, IOContext, int*,
uint64_t*, DispatchResult*, Context *));
bool write_same(
uint64_t object_no, uint64_t object_off, uint64_t object_len,
LightweightBufferExtents&& buffer_extents, ceph::bufferlist&& data,
- const ::SnapContext &snapc, int op_flags,
+ IOContext io_context, int op_flags,
const ZTracer::Trace &parent_trace, int* dispatch_flags,
uint64_t* journal_tid, DispatchResult* dispatch_result,
Context* *on_finish, Context* on_dispatched) override {
return execute_write_same(object_no, object_off, object_len, buffer_extents,
- data, snapc, dispatch_flags, journal_tid,
+ data, io_context, dispatch_flags, journal_tid,
dispatch_result, on_dispatched);
}
DispatchResult*, Context *));
bool compare_and_write(
uint64_t object_no, uint64_t object_off, ceph::bufferlist&& cmp_data,
- ceph::bufferlist&& write_data, const ::SnapContext &snapc, int op_flags,
+ ceph::bufferlist&& write_data, IOContext io_context, int op_flags,
const ZTracer::Trace &parent_trace, uint64_t* mismatch_offset,
int* dispatch_flags, uint64_t* journal_tid,
DispatchResult* dispatch_result, Context** on_finish,
projects / ceph.git / commitdiff