From b12b8c447a41e0a28cea52df88131aa1e4070a69 Mon Sep 17 00:00:00 2001 From: Jason Dillaman Date: Thu, 7 May 2020 21:55:44 -0400 Subject: [PATCH] librbd: switch to new api::Io dispatch helper methods This is another step in the removal of ImageRequestWQ in favor of the new ImageDispatcher. Signed-off-by: Jason Dillaman --- src/librbd/LibrbdAdminSocketHook.cc | 4 +- src/librbd/internal.cc | 11 +- src/librbd/io/ImageDispatch.cc | 24 +++ src/librbd/librbd.cc | 142 ++++++++------- .../deep_copy/test_mock_ObjectCopyRequest.cc | 27 +-- src/test/librbd/io/test_mock_CopyupRequest.cc | 4 +- src/test/librbd/journal/test_Entries.cc | 41 +++-- src/test/librbd/journal/test_Replay.cc | 48 ++--- src/test/librbd/test_DeepCopy.cc | 127 ++++++------- src/test/librbd/test_Migration.cc | 32 ++-- src/test/librbd/test_fixture.cc | 4 +- src/test/librbd/test_internal.cc | 167 +++++++++--------- src/test/rbd_mirror/test_ImageReplayer.cc | 10 +- src/test/rbd_mirror/test_ImageSync.cc | 61 ++++--- 14 files changed, 374 insertions(+), 328 deletions(-) diff --git a/src/librbd/LibrbdAdminSocketHook.cc b/src/librbd/LibrbdAdminSocketHook.cc index 6b7a2b53c98..f91bda3f0d2 100644 --- a/src/librbd/LibrbdAdminSocketHook.cc +++ b/src/librbd/LibrbdAdminSocketHook.cc @@ -6,7 +6,7 @@ #include "librbd/ImageCtx.h" #include "librbd/LibrbdAdminSocketHook.h" #include "librbd/internal.h" -#include "librbd/io/ImageRequestWQ.h" +#include "librbd/api/Io.h" #define dout_subsys ceph_subsys_rbd #undef dout_prefix @@ -25,7 +25,7 @@ public: explicit FlushCacheCommand(ImageCtx *ictx) : ictx(ictx) {} int call(Formatter *f) override { - return ictx->io_work_queue->flush(); + return api::Io<>::flush(*ictx); } private: diff --git a/src/librbd/internal.cc b/src/librbd/internal.cc index 50559bc445c..f6b764a7449 100644 --- a/src/librbd/internal.cc +++ b/src/librbd/internal.cc @@ -34,6 +34,7 @@ #include "librbd/Utils.h" #include "librbd/api/Config.h" #include "librbd/api/Image.h" +#include "librbd/api/Io.h" #include "librbd/exclusive_lock/AutomaticPolicy.h" #include "librbd/exclusive_lock/StandardPolicy.h" #include "librbd/deep_copy/MetadataCopyRequest.h" @@ -43,7 +44,6 @@ #include "librbd/image/Types.h" #include "librbd/io/AioCompletion.h" #include "librbd/io/ImageRequest.h" -#include "librbd/io/ImageRequestWQ.h" #include "librbd/io/ObjectDispatcherInterface.h" #include "librbd/io/ObjectRequest.h" #include "librbd/io/ReadResult.h" @@ -1238,11 +1238,10 @@ int validate_pool(IoCtx &io_ctx, CephContext *cct) { auto comp = io::AioCompletion::create(ctx); // coordinate through AIO WQ to ensure lock is acquired if needed - m_dest->io_work_queue->aio_write(comp, m_offset + write_offset, - write_length, - std::move(*write_bl), - LIBRADOS_OP_FLAG_FADVISE_DONTNEED, - std::move(read_trace)); + api::Io<>::aio_write(*m_dest, comp, m_offset + write_offset, + write_length, std::move(*write_bl), + LIBRADOS_OP_FLAG_FADVISE_DONTNEED, + std::move(read_trace)); write_offset = offset; write_length = 0; } diff --git a/src/librbd/io/ImageDispatch.cc b/src/librbd/io/ImageDispatch.cc index 2cd9f7a0b24..0191cabacd7 100644 --- a/src/librbd/io/ImageDispatch.cc +++ b/src/librbd/io/ImageDispatch.cc @@ -5,6 +5,7 @@ #include "common/dout.h" #include "common/WorkQueue.h" #include "librbd/ImageCtx.h" +#include "librbd/io/AioCompletion.h" #include "librbd/io/ImageRequest.h" #define dout_subsys ceph_subsys_rbd @@ -15,6 +16,17 @@ namespace librbd { namespace io { +namespace { + +void start_in_flight_io(AioCompletion* aio_comp) { + // TODO remove AsyncOperation from AioCompletion + if (!aio_comp->async_op.started()) { + aio_comp->start_op(); + } +} + +} // anonymous namespace + template void ImageDispatch::shut_down(Context* on_finish) { on_finish->complete(0); @@ -29,6 +41,8 @@ bool ImageDispatch::read( auto cct = m_image_ctx->cct; ldout(cct, 20) << "image_extents=" << image_extents << dendl; + start_in_flight_io(aio_comp); + *dispatch_result = DISPATCH_RESULT_COMPLETE; ImageRequest::aio_read( m_image_ctx, aio_comp, std::move(image_extents), std::move(read_result), @@ -45,6 +59,8 @@ bool ImageDispatch::write( auto cct = m_image_ctx->cct; ldout(cct, 20) << "image_extents=" << image_extents << dendl; + start_in_flight_io(aio_comp); + *dispatch_result = DISPATCH_RESULT_COMPLETE; ImageRequest::aio_write( m_image_ctx, aio_comp, std::move(image_extents), std::move(bl), op_flags, @@ -61,6 +77,8 @@ bool ImageDispatch::discard( auto cct = m_image_ctx->cct; ldout(cct, 20) << "image_extents=" << image_extents << dendl; + start_in_flight_io(aio_comp); + *dispatch_result = DISPATCH_RESULT_COMPLETE; ImageRequest::aio_discard( m_image_ctx, aio_comp, std::move(image_extents), discard_granularity_bytes, @@ -77,6 +95,8 @@ bool ImageDispatch::write_same( auto cct = m_image_ctx->cct; ldout(cct, 20) << "image_extents=" << image_extents << dendl; + start_in_flight_io(aio_comp); + *dispatch_result = DISPATCH_RESULT_COMPLETE; ImageRequest::aio_writesame( m_image_ctx, aio_comp, std::move(image_extents), std::move(bl), op_flags, @@ -94,6 +114,8 @@ bool ImageDispatch::compare_and_write( auto cct = m_image_ctx->cct; ldout(cct, 20) << "image_extents=" << image_extents << dendl; + start_in_flight_io(aio_comp); + *dispatch_result = DISPATCH_RESULT_COMPLETE; ImageRequest::aio_compare_and_write( m_image_ctx, aio_comp, std::move(image_extents), std::move(cmp_bl), @@ -110,6 +132,8 @@ bool ImageDispatch::flush( auto cct = m_image_ctx->cct; ldout(cct, 20) << dendl; + start_in_flight_io(aio_comp); + *dispatch_result = DISPATCH_RESULT_COMPLETE; ImageRequest::aio_flush(m_image_ctx, aio_comp, flush_source, parent_trace); return true; diff --git a/src/librbd/librbd.cc b/src/librbd/librbd.cc index 239e078f282..fdb9002510c 100644 --- a/src/librbd/librbd.cc +++ b/src/librbd/librbd.cc @@ -32,6 +32,7 @@ #include "librbd/api/DiffIterate.h" #include "librbd/api/Group.h" #include "librbd/api/Image.h" +#include "librbd/api/Io.h" #include "librbd/api/Migration.h" #include "librbd/api/Mirror.h" #include "librbd/api/Namespace.h" @@ -40,7 +41,6 @@ #include "librbd/api/Snapshot.h" #include "librbd/api/Trash.h" #include "librbd/io/AioCompletion.h" -#include "librbd/io/ImageRequestWQ.h" #include "librbd/io/ReadResult.h" #include #include @@ -2423,8 +2423,8 @@ namespace librbd { tracepoint(librbd, read_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, ofs, len); bufferptr ptr(len); bl.push_back(std::move(ptr)); - - int r = ictx->io_work_queue->read(ofs, len, io::ReadResult{&bl}, 0); + + int r = api::Io<>::read(*ictx, ofs, len, io::ReadResult{&bl}, 0); tracepoint(librbd, read_exit, r); return r; } @@ -2436,8 +2436,8 @@ namespace librbd { ictx->read_only, ofs, len, op_flags); bufferptr ptr(len); bl.push_back(std::move(ptr)); - - int r = ictx->io_work_queue->read(ofs, len, io::ReadResult{&bl}, op_flags); + + int r = api::Io<>::read(*ictx, ofs, len, io::ReadResult{&bl}, op_flags); tracepoint(librbd, read_exit, r); return r; } @@ -2448,7 +2448,7 @@ namespace librbd { { ImageCtx *ictx = (ImageCtx *)ctx; tracepoint(librbd, read_iterate_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, ofs, len); - + int64_t r = librbd::read_iterate(ictx, ofs, len, cb, arg); tracepoint(librbd, read_iterate_exit, r); return r; @@ -2460,7 +2460,7 @@ namespace librbd { { ImageCtx *ictx = (ImageCtx *)ctx; tracepoint(librbd, read_iterate2_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, ofs, len); - + int64_t r = librbd::read_iterate(ictx, ofs, len, cb, arg); if (r > 0) r = 0; @@ -2511,7 +2511,7 @@ namespace librbd { return -EINVAL; } - int r = ictx->io_work_queue->write(ofs, len, bufferlist{bl}, 0); + int r = api::Io<>::write(*ictx, ofs, len, bufferlist{bl}, 0); tracepoint(librbd, write_exit, r); return r; } @@ -2526,7 +2526,7 @@ namespace librbd { return -EINVAL; } - int r = ictx->io_work_queue->write(ofs, len, bufferlist{bl}, op_flags); + int r = api::Io<>::write(*ictx, ofs, len, bufferlist{bl}, op_flags); tracepoint(librbd, write_exit, r); return r; } @@ -2539,8 +2539,8 @@ namespace librbd { tracepoint(librbd, discard_exit, -EINVAL); return -EINVAL; } - int r = ictx->io_work_queue->discard( - ofs, len, ictx->discard_granularity_bytes); + int r = api::Io<>::discard( + *ictx, ofs, len, ictx->discard_granularity_bytes); tracepoint(librbd, discard_exit, r); return r; } @@ -2559,12 +2559,12 @@ namespace librbd { bool discard_zero = ictx->config.get_val("rbd_discard_on_zeroed_write_same"); if (discard_zero && mem_is_zero(bl.c_str(), bl.length())) { - int r = ictx->io_work_queue->discard(ofs, len, 0); + int r = api::Io<>::discard(*ictx, ofs, len, 0); tracepoint(librbd, writesame_exit, r); return r; } - int r = ictx->io_work_queue->writesame(ofs, len, bufferlist{bl}, op_flags); + int r = api::Io<>::write_same(*ictx, ofs, len, bufferlist{bl}, op_flags); tracepoint(librbd, writesame_exit, r); return r; } @@ -2584,9 +2584,9 @@ namespace librbd { return -EINVAL; } - int r = ictx->io_work_queue->compare_and_write(ofs, len, bufferlist{cmp_bl}, - bufferlist{bl}, mismatch_off, - op_flags); + int r = api::Io<>::compare_and_write( + *ictx, ofs, len, bufferlist{cmp_bl}, bufferlist{bl}, mismatch_off, + op_flags); tracepoint(librbd, compare_and_write_exit, r); @@ -2602,8 +2602,8 @@ namespace librbd { tracepoint(librbd, aio_write_exit, -EINVAL); return -EINVAL; } - ictx->io_work_queue->aio_write(get_aio_completion(c), off, len, - bufferlist{bl}, 0); + api::Io<>::aio_write(*ictx, get_aio_completion(c), off, len, bufferlist{bl}, + 0, true); tracepoint(librbd, aio_write_exit, 0); return 0; @@ -2619,8 +2619,8 @@ namespace librbd { tracepoint(librbd, aio_write_exit, -EINVAL); return -EINVAL; } - ictx->io_work_queue->aio_write(get_aio_completion(c), off, len, - bufferlist{bl}, op_flags); + api::Io<>::aio_write(*ictx, get_aio_completion(c), off, len, bufferlist{bl}, + op_flags, true); tracepoint(librbd, aio_write_exit, 0); return 0; @@ -2630,8 +2630,9 @@ namespace librbd { { ImageCtx *ictx = (ImageCtx *)ctx; tracepoint(librbd, aio_discard_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, off, len, c->pc); - ictx->io_work_queue->aio_discard( - get_aio_completion(c), off, len, ictx->discard_granularity_bytes); + api::Io<>::aio_discard( + *ictx, get_aio_completion(c), off, len, ictx->discard_granularity_bytes, + true); tracepoint(librbd, aio_discard_exit, 0); return 0; } @@ -2644,8 +2645,8 @@ namespace librbd { ldout(ictx->cct, 10) << "Image::aio_read() buf=" << (void *)bl.c_str() << "~" << (void *)(bl.c_str() + len - 1) << dendl; - ictx->io_work_queue->aio_read(get_aio_completion(c), off, len, - io::ReadResult{&bl}, 0); + api::Io<>::aio_read(*ictx, get_aio_completion(c), off, len, + io::ReadResult{&bl}, 0, true); tracepoint(librbd, aio_read_exit, 0); return 0; } @@ -2659,8 +2660,8 @@ namespace librbd { ldout(ictx->cct, 10) << "Image::aio_read() buf=" << (void *)bl.c_str() << "~" << (void *)(bl.c_str() + len - 1) << dendl; - ictx->io_work_queue->aio_read(get_aio_completion(c), off, len, - io::ReadResult{&bl}, op_flags); + api::Io<>::aio_read(*ictx, get_aio_completion(c), off, len, + io::ReadResult{&bl}, op_flags, true); tracepoint(librbd, aio_read_exit, 0); return 0; } @@ -2669,7 +2670,7 @@ namespace librbd { { ImageCtx *ictx = (ImageCtx *)ctx; tracepoint(librbd, flush_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only); - int r = ictx->io_work_queue->flush(); + int r = api::Io<>::flush(*ictx); tracepoint(librbd, flush_exit, r); return r; } @@ -2678,7 +2679,7 @@ namespace librbd { { ImageCtx *ictx = (ImageCtx *)ctx; tracepoint(librbd, aio_flush_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, c->pc); - ictx->io_work_queue->aio_flush(get_aio_completion(c)); + api::Io<>::aio_flush(*ictx, get_aio_completion(c), true); tracepoint(librbd, aio_flush_exit, 0); return 0; } @@ -2697,13 +2698,13 @@ namespace librbd { bool discard_zero = ictx->config.get_val("rbd_discard_on_zeroed_write_same"); if (discard_zero && mem_is_zero(bl.c_str(), bl.length())) { - ictx->io_work_queue->aio_discard(get_aio_completion(c), off, len, 0); + api::Io<>::aio_discard(*ictx, get_aio_completion(c), off, len, 0, true); tracepoint(librbd, aio_writesame_exit, 0); return 0; } - ictx->io_work_queue->aio_writesame(get_aio_completion(c), off, len, - bufferlist{bl}, op_flags); + api::Io<>::aio_write_same(*ictx, get_aio_completion(c), off, len, + bufferlist{bl}, op_flags, true); tracepoint(librbd, aio_writesame_exit, 0); return 0; } @@ -2724,9 +2725,9 @@ namespace librbd { return -EINVAL; } - ictx->io_work_queue->aio_compare_and_write(get_aio_completion(c), off, len, - bufferlist{cmp_bl}, bufferlist{bl}, - mismatch_off, op_flags, false); + api::Io<>::aio_compare_and_write(*ictx, get_aio_completion(c), off, len, + bufferlist{cmp_bl}, bufferlist{bl}, + mismatch_off, op_flags, false); tracepoint(librbd, aio_compare_and_write_exit, 0); @@ -5757,8 +5758,8 @@ extern "C" ssize_t rbd_read(rbd_image_t image, uint64_t ofs, size_t len, { librbd::ImageCtx *ictx = (librbd::ImageCtx *)image; tracepoint(librbd, read_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, ofs, len); - int r = ictx->io_work_queue->read(ofs, len, librbd::io::ReadResult{buf, len}, - 0); + int r = librbd::api::Io<>::read( + *ictx, ofs, len, librbd::io::ReadResult{buf, len}, 0); tracepoint(librbd, read_exit, r); return r; } @@ -5769,8 +5770,8 @@ extern "C" ssize_t rbd_read2(rbd_image_t image, uint64_t ofs, size_t len, librbd::ImageCtx *ictx = (librbd::ImageCtx *)image; tracepoint(librbd, read2_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, ofs, len, op_flags); - int r = ictx->io_work_queue->read(ofs, len, librbd::io::ReadResult{buf, len}, - op_flags); + int r = librbd::api::Io<>::read( + *ictx, ofs, len, librbd::io::ReadResult{buf, len}, op_flags); tracepoint(librbd, read_exit, r); return r; } @@ -5845,7 +5846,7 @@ extern "C" ssize_t rbd_write(rbd_image_t image, uint64_t ofs, size_t len, bufferlist bl; bl.push_back(create_write_raw(ictx, buf, len, nullptr)); - int r = ictx->io_work_queue->write(ofs, len, std::move(bl), 0); + int r = librbd::api::Io<>::write(*ictx, ofs, len, std::move(bl), 0); tracepoint(librbd, write_exit, r); return r; } @@ -5859,7 +5860,7 @@ extern "C" ssize_t rbd_write2(rbd_image_t image, uint64_t ofs, size_t len, bufferlist bl; bl.push_back(create_write_raw(ictx, buf, len, nullptr)); - int r = ictx->io_work_queue->write(ofs, len, std::move(bl), op_flags); + int r = librbd::api::Io<>::write(*ictx, ofs, len, std::move(bl), op_flags); tracepoint(librbd, write_exit, r); return r; } @@ -5875,8 +5876,8 @@ extern "C" int rbd_discard(rbd_image_t image, uint64_t ofs, uint64_t len) return -EINVAL; } - int r = ictx->io_work_queue->discard( - ofs, len, ictx->discard_granularity_bytes); + int r = librbd::api::Io<>::discard( + *ictx, ofs, len, ictx->discard_granularity_bytes); tracepoint(librbd, discard_exit, r); return r; } @@ -5896,14 +5897,15 @@ extern "C" ssize_t rbd_writesame(rbd_image_t image, uint64_t ofs, size_t len, bool discard_zero = ictx->config.get_val("rbd_discard_on_zeroed_write_same"); if (discard_zero && mem_is_zero(buf, data_len)) { - int r = ictx->io_work_queue->discard(ofs, len, 0); + int r = librbd::api::Io<>::discard(*ictx, ofs, len, 0); tracepoint(librbd, writesame_exit, r); return r; } bufferlist bl; bl.push_back(create_write_raw(ictx, buf, data_len, nullptr)); - int r = ictx->io_work_queue->writesame(ofs, len, std::move(bl), op_flags); + int r = librbd::api::Io<>::write_same( + *ictx, ofs, len, std::move(bl), op_flags); tracepoint(librbd, writesame_exit, r); return r; } @@ -5925,9 +5927,8 @@ extern "C" ssize_t rbd_compare_and_write(rbd_image_t image, bufferlist bl; bl.push_back(create_write_raw(ictx, buf, len, nullptr)); - int r = ictx->io_work_queue->compare_and_write(ofs, len, std::move(cmp_bl), - std::move(bl), mismatch_off, - op_flags); + int r = librbd::api::Io<>::compare_and_write( + *ictx, ofs, len, std::move(cmp_bl), std::move(bl), mismatch_off, op_flags); tracepoint(librbd, compare_and_write_exit, r); return r; } @@ -5952,7 +5953,8 @@ extern "C" int rbd_aio_write(rbd_image_t image, uint64_t off, size_t len, auto aio_completion = get_aio_completion(comp); bufferlist bl; bl.push_back(create_write_raw(ictx, buf, len, aio_completion)); - ictx->io_work_queue->aio_write(aio_completion, off, len, std::move(bl), 0); + librbd::api::Io<>::aio_write( + *ictx, aio_completion, off, len, std::move(bl), 0, true); tracepoint(librbd, aio_write_exit, 0); return 0; } @@ -5968,8 +5970,8 @@ extern "C" int rbd_aio_write2(rbd_image_t image, uint64_t off, size_t len, auto aio_completion = get_aio_completion(comp); bufferlist bl; bl.push_back(create_write_raw(ictx, buf, len, aio_completion)); - ictx->io_work_queue->aio_write(aio_completion, off, len, std::move(bl), - op_flags); + librbd::api::Io<>::aio_write( + *ictx, aio_completion, off, len, std::move(bl), op_flags, true); tracepoint(librbd, aio_write_exit, 0); return 0; } @@ -6004,7 +6006,8 @@ extern "C" int rbd_aio_writev(rbd_image_t image, const struct iovec *iov, ictx->snap_name.c_str(), ictx->read_only, off, len, NULL, comp->pc); if (r == 0) { - ictx->io_work_queue->aio_write(aio_completion, off, len, std::move(bl), 0); + librbd::api::Io<>::aio_write( + *ictx, aio_completion, off, len, std::move(bl), 0, true); } tracepoint(librbd, aio_write_exit, r); return r; @@ -6016,8 +6019,9 @@ extern "C" int rbd_aio_discard(rbd_image_t image, uint64_t off, uint64_t len, librbd::ImageCtx *ictx = (librbd::ImageCtx *)image; librbd::RBD::AioCompletion *comp = (librbd::RBD::AioCompletion *)c; tracepoint(librbd, aio_discard_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, off, len, comp->pc); - ictx->io_work_queue->aio_discard( - get_aio_completion(comp), off, len, ictx->discard_granularity_bytes); + librbd::api::Io<>::aio_discard( + *ictx, get_aio_completion(comp), off, len, + ictx->discard_granularity_bytes, true); tracepoint(librbd, aio_discard_exit, 0); return 0; } @@ -6028,8 +6032,9 @@ extern "C" int rbd_aio_read(rbd_image_t image, uint64_t off, size_t len, librbd::ImageCtx *ictx = (librbd::ImageCtx *)image; librbd::RBD::AioCompletion *comp = (librbd::RBD::AioCompletion *)c; tracepoint(librbd, aio_read_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, off, len, buf, comp->pc); - ictx->io_work_queue->aio_read(get_aio_completion(comp), off, len, - librbd::io::ReadResult{buf, len}, 0); + librbd::api::Io<>::aio_read( + *ictx, get_aio_completion(comp), off, len, librbd::io::ReadResult{buf, len}, + 0, true); tracepoint(librbd, aio_read_exit, 0); return 0; } @@ -6041,8 +6046,9 @@ extern "C" int rbd_aio_read2(rbd_image_t image, uint64_t off, size_t len, librbd::RBD::AioCompletion *comp = (librbd::RBD::AioCompletion *)c; tracepoint(librbd, aio_read2_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, off, len, buf, comp->pc, op_flags); - ictx->io_work_queue->aio_read(get_aio_completion(comp), off, len, - librbd::io::ReadResult{buf, len},op_flags); + librbd::api::Io<>::aio_read( + *ictx, get_aio_completion(comp), off, len, librbd::io::ReadResult{buf, len}, + op_flags, true); tracepoint(librbd, aio_read_exit, 0); return 0; } @@ -6077,8 +6083,9 @@ extern "C" int rbd_aio_readv(rbd_image_t image, const struct iovec *iov, } else { read_result = librbd::io::ReadResult(iov, iovcnt); } - ictx->io_work_queue->aio_read(get_aio_completion(comp), off, len, - std::move(read_result), 0); + librbd::api::Io<>::aio_read( + *ictx, get_aio_completion(comp), off, len, std::move(read_result), 0, + true); } tracepoint(librbd, aio_read_exit, r); return r; @@ -6088,7 +6095,7 @@ extern "C" int rbd_flush(rbd_image_t image) { librbd::ImageCtx *ictx = (librbd::ImageCtx *)image; tracepoint(librbd, flush_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only); - int r = ictx->io_work_queue->flush(); + int r = librbd::api::Io<>::flush(*ictx); tracepoint(librbd, flush_exit, r); return r; } @@ -6098,7 +6105,7 @@ extern "C" int rbd_aio_flush(rbd_image_t image, rbd_completion_t c) librbd::ImageCtx *ictx = (librbd::ImageCtx *)image; librbd::RBD::AioCompletion *comp = (librbd::RBD::AioCompletion *)c; tracepoint(librbd, aio_flush_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, comp->pc); - ictx->io_work_queue->aio_flush(get_aio_completion(comp)); + librbd::api::Io<>::aio_flush(*ictx, get_aio_completion(comp), true); tracepoint(librbd, aio_flush_exit, 0); return 0; } @@ -6120,7 +6127,8 @@ extern "C" int rbd_aio_writesame(rbd_image_t image, uint64_t off, size_t len, bool discard_zero = ictx->config.get_val("rbd_discard_on_zeroed_write_same"); if (discard_zero && mem_is_zero(buf, data_len)) { - ictx->io_work_queue->aio_discard(get_aio_completion(comp), off, len, 0); + librbd::api::Io<>::aio_discard( + *ictx, get_aio_completion(comp), off, len, 0, true); tracepoint(librbd, aio_writesame_exit, 0); return 0; } @@ -6128,8 +6136,8 @@ extern "C" int rbd_aio_writesame(rbd_image_t image, uint64_t off, size_t len, auto aio_completion = get_aio_completion(comp); bufferlist bl; bl.push_back(create_write_raw(ictx, buf, data_len, aio_completion)); - ictx->io_work_queue->aio_writesame(aio_completion, off, len, std::move(bl), - op_flags); + librbd::api::Io<>::aio_write_same( + *ictx, aio_completion, off, len, std::move(bl), op_flags, true); tracepoint(librbd, aio_writesame_exit, 0); return 0; } @@ -6150,9 +6158,9 @@ extern "C" ssize_t rbd_aio_compare_and_write(rbd_image_t image, uint64_t off, cmp_bl.push_back(create_write_raw(ictx, cmp_buf, len, aio_completion)); bufferlist bl; bl.push_back(create_write_raw(ictx, buf, len, aio_completion)); - ictx->io_work_queue->aio_compare_and_write(aio_completion, off, len, - std::move(cmp_bl), std::move(bl), - mismatch_off, op_flags, false); + librbd::api::Io<>::aio_compare_and_write( + *ictx, aio_completion, off, len, std::move(cmp_bl), std::move(bl), + mismatch_off, op_flags, false); tracepoint(librbd, aio_compare_and_write_exit, 0); return 0; diff --git a/src/test/librbd/deep_copy/test_mock_ObjectCopyRequest.cc b/src/test/librbd/deep_copy/test_mock_ObjectCopyRequest.cc index c2e03db37b7..ba7966c9a38 100644 --- a/src/test/librbd/deep_copy/test_mock_ObjectCopyRequest.cc +++ b/src/test/librbd/deep_copy/test_mock_ObjectCopyRequest.cc @@ -10,9 +10,9 @@ #include "librbd/internal.h" #include "librbd/Operations.h" #include "librbd/api/Image.h" +#include "librbd/api/Io.h" #include "librbd/deep_copy/ObjectCopyRequest.h" #include "librbd/io/ImageRequest.h" -#include "librbd/io/ImageRequestWQ.h" #include "librbd/io/ReadResult.h" #include "test/librados_test_stub/MockTestMemIoCtxImpl.h" #include "test/librbd/mock/MockImageCtx.h" @@ -94,7 +94,7 @@ void scribble(librbd::ImageCtx *image_ctx, int num_ops, size_t max_size, bufferlist bl; bl.append(std::string(len, '1')); - int r = image_ctx->io_work_queue->write(off, len, std::move(bl), 0); + int r = api::Io<>::write(*image_ctx, off, len, std::move(bl), 0); ASSERT_EQ(static_cast(len), r); interval_set w; @@ -376,13 +376,13 @@ public: bufferlist bl; bl.append(std::string(object_size, '1')); - r = m_src_image_ctx->io_work_queue->read( - 0, object_size, librbd::io::ReadResult{&bl}, 0); + r = api::Io<>::read(*m_src_image_ctx, 0, object_size, + librbd::io::ReadResult{&bl}, 0); if (r < 0) { return r; } - r = m_dst_image_ctx->io_work_queue->write(0, object_size, std::move(bl), 0); + r = api::Io<>::write(*m_dst_image_ctx, 0, object_size, std::move(bl), 0); if (r < 0) { return r; } @@ -427,16 +427,16 @@ public: bufferlist src_bl; src_bl.append(std::string(object_size, '1')); - r = m_src_image_ctx->io_work_queue->read( - 0, object_size, librbd::io::ReadResult{&src_bl}, 0); + r = api::Io<>::read( + *m_src_image_ctx, 0, object_size, librbd::io::ReadResult{&src_bl}, 0); if (r < 0) { return r; } bufferlist dst_bl; dst_bl.append(std::string(object_size, '1')); - r = m_dst_image_ctx->io_work_queue->read( - 0, object_size, librbd::io::ReadResult{&dst_bl}, 0); + r = api::Io<>::read( + *m_dst_image_ctx, 0, object_size, librbd::io::ReadResult{&dst_bl}, 0); if (r < 0) { return r; } @@ -793,8 +793,8 @@ TEST_F(TestMockDeepCopyObjectCopyRequest, Trim) { // trim the object uint64_t trim_offset = rand() % one.range_end(); - ASSERT_LE(0, m_src_image_ctx->io_work_queue->discard( - trim_offset, one.range_end() - trim_offset, + ASSERT_LE(0, api::Io<>::discard( + *m_src_image_ctx, trim_offset, one.range_end() - trim_offset, m_src_image_ctx->discard_granularity_bytes)); ASSERT_EQ(0, create_snap("copy")); @@ -849,8 +849,9 @@ TEST_F(TestMockDeepCopyObjectCopyRequest, Remove) { // remove the object uint64_t object_size = 1 << m_src_image_ctx->order; - ASSERT_LE(0, m_src_image_ctx->io_work_queue->discard( - 0, object_size, m_src_image_ctx->discard_granularity_bytes)); + ASSERT_LE(0, api::Io<>::discard( + *m_src_image_ctx, 0, object_size, + m_src_image_ctx->discard_granularity_bytes)); ASSERT_EQ(0, create_snap("copy")); librbd::MockTestImageCtx mock_src_image_ctx(*m_src_image_ctx); librbd::MockTestImageCtx mock_dst_image_ctx(*m_dst_image_ctx); diff --git a/src/test/librbd/io/test_mock_CopyupRequest.cc b/src/test/librbd/io/test_mock_CopyupRequest.cc index 6a979b0ceb7..5d87ae6f6c2 100644 --- a/src/test/librbd/io/test_mock_CopyupRequest.cc +++ b/src/test/librbd/io/test_mock_CopyupRequest.cc @@ -10,10 +10,10 @@ #include "test/librados_test_stub/MockTestMemIoCtxImpl.h" #include "test/librados_test_stub/MockTestMemRadosClient.h" #include "include/rbd/librbd.hpp" +#include "librbd/api/Io.h" #include "librbd/deep_copy/ObjectCopyRequest.h" #include "librbd/io/CopyupRequest.h" #include "librbd/io/ImageRequest.h" -#include "librbd/io/ImageRequestWQ.h" #include "librbd/io/ObjectRequest.h" #include "librbd/io/ReadResult.h" @@ -336,7 +336,7 @@ struct TestMockIoCopyupRequest : public TestMockFixture { } void flush_async_operations(librbd::ImageCtx* ictx) { - ictx->io_work_queue->flush(); + api::Io<>::flush(*ictx); } std::string m_parent_image_name; diff --git a/src/test/librbd/journal/test_Entries.cc b/src/test/librbd/journal/test_Entries.cc index 353886626d7..d89c4f8e423 100644 --- a/src/test/librbd/journal/test_Entries.cc +++ b/src/test/librbd/journal/test_Entries.cc @@ -5,8 +5,8 @@ #include "test/librbd/test_support.h" #include "librbd/internal.h" #include "librbd/Journal.h" +#include "librbd/api/Io.h" #include "librbd/io/AioCompletion.h" -#include "librbd/io/ImageRequestWQ.h" #include "librbd/journal/Types.h" #include "journal/Journaler.h" #include "journal/ReplayEntry.h" @@ -18,11 +18,14 @@ void register_test_journal_entries() { } +namespace librbd { +namespace journal { + class TestJournalEntries : public TestFixture { public: - typedef std::list Journalers; + typedef std::list<::journal::Journaler *> Journalers; - struct ReplayHandler : public journal::ReplayHandler { + struct ReplayHandler : public ::journal::ReplayHandler { ceph::mutex lock = ceph::make_mutex("ReplayHandler::lock"); ceph::condition_variable cond; bool entries_available; @@ -51,7 +54,7 @@ public: void TearDown() override { for (Journalers::iterator it = m_journalers.begin(); it != m_journalers.end(); ++it) { - journal::Journaler *journaler = *it; + ::journal::Journaler *journaler = *it; journaler->stop_replay(); journaler->shut_down(); delete journaler; @@ -60,8 +63,8 @@ public: TestFixture::TearDown(); } - journal::Journaler *create_journaler(librbd::ImageCtx *ictx) { - journal::Journaler *journaler = new journal::Journaler( + ::journal::Journaler *create_journaler(librbd::ImageCtx *ictx) { + ::journal::Journaler *journaler = new ::journal::Journaler( ictx->md_ctx, ictx->id, "dummy client", {}, nullptr); int r = journaler->register_client(bufferlist()); @@ -96,7 +99,7 @@ public: return true; } - bool get_event_entry(const journal::ReplayEntry &replay_entry, + bool get_event_entry(const ::journal::ReplayEntry &replay_entry, librbd::journal::EventEntry *event_entry) { try { bufferlist data_bl = replay_entry.get_data(); @@ -116,7 +119,7 @@ TEST_F(TestJournalEntries, AioWrite) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - journal::Journaler *journaler = create_journaler(ictx); + ::journal::Journaler *journaler = create_journaler(ictx); ASSERT_TRUE(journaler != NULL); std::string buffer(512, '1'); @@ -126,13 +129,14 @@ TEST_F(TestJournalEntries, AioWrite) { C_SaferCond cond_ctx; auto c = librbd::io::AioCompletion::create(&cond_ctx); c->get(); - ictx->io_work_queue->aio_write(c, 123, buffer.size(), std::move(write_bl), 0); + api::Io<>::aio_write(*ictx, c, 123, buffer.size(), std::move(write_bl), 0, + true); ASSERT_EQ(0, c->wait_for_complete()); c->put(); ASSERT_TRUE(wait_for_entries_available(ictx)); - journal::ReplayEntry replay_entry; + ::journal::ReplayEntry replay_entry; ASSERT_TRUE(journaler->try_pop_front(&replay_entry)); librbd::journal::EventEntry event_entry; @@ -163,20 +167,20 @@ TEST_F(TestJournalEntries, AioDiscard) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - journal::Journaler *journaler = create_journaler(ictx); + ::journal::Journaler *journaler = create_journaler(ictx); ASSERT_TRUE(journaler != NULL); C_SaferCond cond_ctx; auto c = librbd::io::AioCompletion::create(&cond_ctx); c->get(); - ictx->io_work_queue->aio_discard(c, 123, 234, - ictx->discard_granularity_bytes); + api::Io<>::aio_discard(*ictx, c, 123, 234, ictx->discard_granularity_bytes, + true); ASSERT_EQ(0, c->wait_for_complete()); c->put(); ASSERT_TRUE(wait_for_entries_available(ictx)); - journal::ReplayEntry replay_entry; + ::journal::ReplayEntry replay_entry; ASSERT_TRUE(journaler->try_pop_front(&replay_entry)); librbd::journal::EventEntry event_entry; @@ -197,19 +201,19 @@ TEST_F(TestJournalEntries, AioFlush) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - journal::Journaler *journaler = create_journaler(ictx); + ::journal::Journaler *journaler = create_journaler(ictx); ASSERT_TRUE(journaler != NULL); C_SaferCond cond_ctx; auto c = librbd::io::AioCompletion::create(&cond_ctx); c->get(); - ictx->io_work_queue->aio_flush(c); + api::Io<>::aio_flush(*ictx, c, true); ASSERT_EQ(0, c->wait_for_complete()); c->put(); ASSERT_TRUE(wait_for_entries_available(ictx)); - journal::ReplayEntry replay_entry; + ::journal::ReplayEntry replay_entry; ASSERT_TRUE(journaler->try_pop_front(&replay_entry)); librbd::journal::EventEntry event_entry; @@ -218,3 +222,6 @@ TEST_F(TestJournalEntries, AioFlush) { ASSERT_EQ(librbd::journal::EVENT_TYPE_AIO_FLUSH, event_entry.get_event_type()); } + +} // namespace journal +} // namespace librbd diff --git a/src/test/librbd/journal/test_Replay.cc b/src/test/librbd/journal/test_Replay.cc index e5d1c0beff5..68f41a7ab25 100644 --- a/src/test/librbd/journal/test_Replay.cc +++ b/src/test/librbd/journal/test_Replay.cc @@ -14,17 +14,20 @@ #include "librbd/internal.h" #include "librbd/Journal.h" #include "librbd/Operations.h" +#include "librbd/api/Io.h" #include "librbd/api/Snapshot.h" #include "librbd/io/AioCompletion.h" #include "librbd/io/ImageDispatchSpec.h" #include "librbd/io/ImageRequest.h" -#include "librbd/io/ImageRequestWQ.h" #include "librbd/io/ReadResult.h" #include "librbd/journal/Types.h" void register_test_journal_replay() { } +namespace librbd { +namespace journal { + class TestJournalReplay : public TestFixture { public: @@ -114,21 +117,21 @@ TEST_F(TestJournalReplay, AioDiscardEvent) { bufferlist payload_bl; payload_bl.append(payload); auto aio_comp = new librbd::io::AioCompletion(); - ictx->io_work_queue->aio_write(aio_comp, 0, payload.size(), - std::move(payload_bl), 0); + api::Io<>::aio_write(*ictx, aio_comp, 0, payload.size(), + std::move(payload_bl), 0, true); ASSERT_EQ(0, aio_comp->wait_for_complete()); aio_comp->release(); aio_comp = new librbd::io::AioCompletion(); - ictx->io_work_queue->aio_flush(aio_comp); + api::Io<>::aio_flush(*ictx, aio_comp, true); ASSERT_EQ(0, aio_comp->wait_for_complete()); aio_comp->release(); std::string read_payload(4096, '\0'); librbd::io::ReadResult read_result{&read_payload[0], read_payload.size()}; aio_comp = new librbd::io::AioCompletion(); - ictx->io_work_queue->aio_read(aio_comp, 0, read_payload.size(), - librbd::io::ReadResult{read_result}, 0); + api::Io<>::aio_read(*ictx, aio_comp, 0, read_payload.size(), + librbd::io::ReadResult{read_result}, 0, true); ASSERT_EQ(0, aio_comp->wait_for_complete()); aio_comp->release(); ASSERT_EQ(payload, read_payload); @@ -153,8 +156,8 @@ TEST_F(TestJournalReplay, AioDiscardEvent) { ASSERT_EQ(0, when_acquired_lock(ictx)); aio_comp = new librbd::io::AioCompletion(); - ictx->io_work_queue->aio_read(aio_comp, 0, read_payload.size(), - librbd::io::ReadResult{read_result}, 0); + api::Io<>::aio_read(*ictx, aio_comp, 0, read_payload.size(), + librbd::io::ReadResult{read_result}, 0, true); ASSERT_EQ(0, aio_comp->wait_for_complete()); aio_comp->release(); if (ictx->discard_granularity_bytes > 0) { @@ -187,8 +190,8 @@ TEST_F(TestJournalReplay, AioDiscardEvent) { // verify lock ordering constraints aio_comp = new librbd::io::AioCompletion(); - ictx->io_work_queue->aio_discard(aio_comp, 0, read_payload.size(), - ictx->discard_granularity_bytes); + api::Io<>::aio_discard(*ictx, aio_comp, 0, read_payload.size(), + ictx->discard_granularity_bytes, true); ASSERT_EQ(0, aio_comp->wait_for_complete()); aio_comp->release(); } @@ -220,8 +223,8 @@ TEST_F(TestJournalReplay, AioWriteEvent) { std::string read_payload(4096, '\0'); librbd::io::ReadResult read_result{&read_payload[0], read_payload.size()}; auto aio_comp = new librbd::io::AioCompletion(); - ictx->io_work_queue->aio_read(aio_comp, 0, read_payload.size(), - std::move(read_result), 0); + api::Io<>::aio_read(*ictx, aio_comp, 0, read_payload.size(), + std::move(read_result), 0, true); ASSERT_EQ(0, aio_comp->wait_for_complete()); aio_comp->release(); ASSERT_EQ(payload, read_payload); @@ -248,8 +251,8 @@ TEST_F(TestJournalReplay, AioWriteEvent) { // verify lock ordering constraints aio_comp = new librbd::io::AioCompletion(); - ictx->io_work_queue->aio_write(aio_comp, 0, payload.size(), - bufferlist{payload_bl}, 0); + api::Io<>::aio_write(*ictx, aio_comp, 0, payload.size(), + bufferlist{payload_bl}, 0, true); ASSERT_EQ(0, aio_comp->wait_for_complete()); aio_comp->release(); } @@ -295,7 +298,7 @@ TEST_F(TestJournalReplay, AioFlushEvent) { // verify lock ordering constraints auto aio_comp = new librbd::io::AioCompletion(); - ictx->io_work_queue->aio_flush(aio_comp); + api::Io<>::aio_flush(*ictx, aio_comp, true); ASSERT_EQ(0, aio_comp->wait_for_complete()); aio_comp->release(); } @@ -827,13 +830,13 @@ TEST_F(TestJournalReplay, ObjectPosition) { bufferlist payload_bl; payload_bl.append(payload); auto aio_comp = new librbd::io::AioCompletion(); - ictx->io_work_queue->aio_write(aio_comp, 0, payload.size(), - bufferlist{payload_bl}, 0); + api::Io<>::aio_write(*ictx, aio_comp, 0, payload.size(), + bufferlist{payload_bl}, 0, true); ASSERT_EQ(0, aio_comp->wait_for_complete()); aio_comp->release(); aio_comp = new librbd::io::AioCompletion(); - ictx->io_work_queue->aio_flush(aio_comp); + api::Io<>::aio_flush(*ictx, aio_comp, true); ASSERT_EQ(0, aio_comp->wait_for_complete()); aio_comp->release(); @@ -847,13 +850,13 @@ TEST_F(TestJournalReplay, ObjectPosition) { // write again aio_comp = new librbd::io::AioCompletion(); - ictx->io_work_queue->aio_write(aio_comp, 0, payload.size(), - bufferlist{payload_bl}, 0); + api::Io<>::aio_write(*ictx, aio_comp, 0, payload.size(), + bufferlist{payload_bl}, 0, true); ASSERT_EQ(0, aio_comp->wait_for_complete()); aio_comp->release(); aio_comp = new librbd::io::AioCompletion(); - ictx->io_work_queue->aio_flush(aio_comp); + api::Io<>::aio_flush(*ictx, aio_comp, true); ASSERT_EQ(0, aio_comp->wait_for_complete()); aio_comp->release(); @@ -872,3 +875,6 @@ TEST_F(TestJournalReplay, ObjectPosition) { ASSERT_EQ(initial_tag + 1, current_tag); ASSERT_EQ(3, current_entry); } + +} // namespace journal +} // namespace librbd diff --git a/src/test/librbd/test_DeepCopy.cc b/src/test/librbd/test_DeepCopy.cc index 6bdb82c1cd9..9f75089598a 100644 --- a/src/test/librbd/test_DeepCopy.cc +++ b/src/test/librbd/test_DeepCopy.cc @@ -4,15 +4,17 @@ #include "test/librbd/test_fixture.h" #include "test/librbd/test_support.h" #include "librbd/Operations.h" +#include "librbd/api/Io.h" #include "librbd/api/Image.h" #include "librbd/api/Snapshot.h" #include "librbd/internal.h" -#include "librbd/io/ImageRequestWQ.h" #include "librbd/io/ReadResult.h" void register_test_deep_copy() { } +namespace librbd { + struct TestDeepCopy : public TestFixture { void SetUp() override { TestFixture::SetUp(); @@ -21,7 +23,7 @@ struct TestDeepCopy : public TestFixture { int order = 22; uint64_t size = (1 << order) * 20; uint64_t features = 0; - bool old_format = !get_features(&features); + bool old_format = !::get_features(&features); EXPECT_EQ(0, create_image_full_pp(m_rbd, m_ioctx, image_name, size, features, old_format, &order)); ASSERT_EQ(0, open_image(image_name, &m_src_ictx)); @@ -49,7 +51,7 @@ struct TestDeepCopy : public TestFixture { void deep_copy() { std::string dst_name = get_temp_image_name(); librbd::NoOpProgressContext no_op; - EXPECT_EQ(0, m_src_ictx->io_work_queue->flush()); + EXPECT_EQ(0, api::Io<>::flush(*m_src_ictx)); EXPECT_EQ(0, librbd::api::Image<>::deep_copy(m_src_ictx, m_src_ictx->md_ctx, dst_name.c_str(), m_opts, no_op)); @@ -104,15 +106,17 @@ struct TestDeepCopy : public TestFixture { bufferlist src_bl; src_bl.push_back(src_ptr); librbd::io::ReadResult src_result{&src_bl}; - EXPECT_EQ(read_size, m_src_ictx->io_work_queue->read( - offset, read_size, librbd::io::ReadResult{src_result}, 0)); + EXPECT_EQ(read_size, api::Io<>::read( + *m_src_ictx, offset, read_size, + librbd::io::ReadResult{src_result}, 0)); bufferptr dst_ptr(read_size); bufferlist dst_bl; dst_bl.push_back(dst_ptr); librbd::io::ReadResult dst_result{&dst_bl}; - EXPECT_EQ(read_size, m_dst_ictx->io_work_queue->read( - offset, read_size, librbd::io::ReadResult{dst_result}, 0)); + EXPECT_EQ(read_size, api::Io<>::read( + *m_dst_ictx, offset, read_size, + librbd::io::ReadResult{dst_result}, 0)); if (!src_bl.contents_equal(dst_bl)) { std::cout << "snap: " << (src_snap_name ? src_snap_name : "null") @@ -131,68 +135,66 @@ struct TestDeepCopy : public TestFixture { bufferlist bl; bl.append(std::string(((1 << m_src_ictx->order) * 2) + 1, '1')); ASSERT_EQ(static_cast(bl.length()), - m_src_ictx->io_work_queue->write(0 * bl.length(), bl.length(), - bufferlist{bl}, 0)); + api::Io<>::write(*m_src_ictx, 0 * bl.length(), bl.length(), + bufferlist{bl}, 0)); ASSERT_EQ(static_cast(bl.length()), - m_src_ictx->io_work_queue->write(2 * bl.length(), bl.length(), - bufferlist{bl}, 0)); + api::Io<>::write(*m_src_ictx, 2 * bl.length(), bl.length(), + bufferlist{bl}, 0)); } void test_snaps() { bufferlist bl; bl.append(std::string(((1 << m_src_ictx->order) * 2) + 1, '1')); ASSERT_EQ(static_cast(bl.length()), - m_src_ictx->io_work_queue->write(0 * bl.length(), bl.length(), - bufferlist{bl}, 0)); - ASSERT_EQ(0, m_src_ictx->io_work_queue->flush()); + api::Io<>::write(*m_src_ictx, 0 * bl.length(), bl.length(), + bufferlist{bl}, 0)); + ASSERT_EQ(0, api::Io<>::flush(*m_src_ictx)); ASSERT_EQ(0, snap_create(*m_src_ictx, "snap1")); ASSERT_EQ(static_cast(bl.length()), - m_src_ictx->io_work_queue->write(1 * bl.length(), bl.length(), - bufferlist{bl}, 0)); + api::Io<>::write(*m_src_ictx, 1 * bl.length(), bl.length(), + bufferlist{bl}, 0)); bufferlist bl1; bl1.append(std::string(1000, 'X')); ASSERT_EQ(static_cast(bl1.length()), - m_src_ictx->io_work_queue->write(0 * bl.length(), bl1.length(), - bufferlist{bl1}, 0)); + api::Io<>::write(*m_src_ictx, 0 * bl.length(), bl1.length(), + bufferlist{bl1}, 0)); ASSERT_EQ(static_cast(bl1.length()), - m_src_ictx->io_work_queue->discard(bl1.length() + 10, - bl1.length(), false)); + api::Io<>::discard(*m_src_ictx, bl1.length() + 10, + bl1.length(), false)); - ASSERT_EQ(0, m_src_ictx->io_work_queue->flush()); + ASSERT_EQ(0, api::Io<>::flush(*m_src_ictx)); ASSERT_EQ(0, snap_create(*m_src_ictx, "snap2")); ASSERT_EQ(static_cast(bl1.length()), - m_src_ictx->io_work_queue->write(1 * bl.length(), bl1.length(), - bufferlist{bl1}, 0)); + api::Io<>::write(*m_src_ictx, 1 * bl.length(), bl1.length(), + bufferlist{bl1}, 0)); ASSERT_EQ(static_cast(bl1.length()), - m_src_ictx->io_work_queue->discard(2 * bl1.length() + 10, - bl1.length(), false)); + api::Io<>::discard(*m_src_ictx, 2 * bl1.length() + 10, + bl1.length(), false)); } void test_snap_discard() { bufferlist bl; bl.append(std::string(100, '1')); ASSERT_EQ(static_cast(bl.length()), - m_src_ictx->io_work_queue->write(0, bl.length(), bufferlist{bl}, - 0)); - ASSERT_EQ(0, m_src_ictx->io_work_queue->flush()); + api::Io<>::write(*m_src_ictx, 0, bl.length(), bufferlist{bl}, 0)); + ASSERT_EQ(0, api::Io<>::flush(*m_src_ictx)); ASSERT_EQ(0, snap_create(*m_src_ictx, "snap")); size_t len = (1 << m_src_ictx->order) * 2; ASSERT_EQ(static_cast(len), - m_src_ictx->io_work_queue->discard(0, len, false)); + api::Io<>::discard(*m_src_ictx, 0, len, false)); } void test_clone_discard() { bufferlist bl; bl.append(std::string(100, '1')); ASSERT_EQ(static_cast(bl.length()), - m_src_ictx->io_work_queue->write(0, bl.length(), bufferlist{bl}, - 0)); - ASSERT_EQ(0, m_src_ictx->io_work_queue->flush()); + api::Io<>::write(*m_src_ictx, 0, bl.length(), bufferlist{bl}, 0)); + ASSERT_EQ(0, api::Io<>::flush(*m_src_ictx)); ASSERT_EQ(0, snap_create(*m_src_ictx, "snap")); ASSERT_EQ(0, snap_protect(*m_src_ictx, "snap")); @@ -209,16 +211,15 @@ struct TestDeepCopy : public TestFixture { size_t len = (1 << m_src_ictx->order) * 2; ASSERT_EQ(static_cast(len), - m_src_ictx->io_work_queue->discard(0, len, false)); + api::Io<>::discard(*m_src_ictx, 0, len, false)); } void test_clone_shrink() { bufferlist bl; bl.append(std::string(100, '1')); ASSERT_EQ(static_cast(bl.length()), - m_src_ictx->io_work_queue->write(0, bl.length(), bufferlist{bl}, - 0)); - ASSERT_EQ(0, m_src_ictx->io_work_queue->flush()); + api::Io<>::write(*m_src_ictx, 0, bl.length(), bufferlist{bl}, 0)); + ASSERT_EQ(0, api::Io<>::flush(*m_src_ictx)); ASSERT_EQ(0, snap_create(*m_src_ictx, "snap")); ASSERT_EQ(0, snap_protect(*m_src_ictx, "snap")); @@ -242,9 +243,8 @@ struct TestDeepCopy : public TestFixture { bufferlist bl; bl.append(std::string(100, '1')); ASSERT_EQ(static_cast(bl.length()), - m_src_ictx->io_work_queue->write(0, bl.length(), bufferlist{bl}, - 0)); - ASSERT_EQ(0, m_src_ictx->io_work_queue->flush()); + api::Io<>::write(*m_src_ictx, 0, bl.length(), bufferlist{bl}, 0)); + ASSERT_EQ(0, api::Io<>::flush(*m_src_ictx)); ASSERT_EQ(0, snap_create(*m_src_ictx, "snap")); ASSERT_EQ(0, snap_protect(*m_src_ictx, "snap")); @@ -269,9 +269,9 @@ struct TestDeepCopy : public TestFixture { bufferlist bl; bl.append(std::string(100, '1')); ASSERT_EQ(static_cast(bl.length()), - m_src_ictx->io_work_queue->write(object_size, bl.length(), - bufferlist{bl}, 0)); - ASSERT_EQ(0, m_src_ictx->io_work_queue->flush()); + api::Io<>::write(*m_src_ictx, object_size, bl.length(), + bufferlist{bl}, 0)); + ASSERT_EQ(0, api::Io<>::flush(*m_src_ictx)); ASSERT_EQ(0, snap_create(*m_src_ictx, "snap")); ASSERT_EQ(0, snap_protect(*m_src_ictx, "snap")); @@ -289,9 +289,8 @@ struct TestDeepCopy : public TestFixture { ASSERT_EQ(0, snap_create(*m_src_ictx, "snap1")); ASSERT_EQ(static_cast(bl.length()), - m_src_ictx->io_work_queue->discard(object_size, bl.length(), - false)); - ASSERT_EQ(0, m_src_ictx->io_work_queue->flush()); + api::Io<>::discard(*m_src_ictx, object_size, bl.length(), false)); + ASSERT_EQ(0, api::Io<>::flush(*m_src_ictx)); ASSERT_EQ(0, snap_create(*m_src_ictx, "snap2")); @@ -307,12 +306,12 @@ struct TestDeepCopy : public TestFixture { bufferlist bl; bl.append(std::string(((1 << m_src_ictx->order) * 2) + 1, '1')); ASSERT_EQ(static_cast(bl.length()), - m_src_ictx->io_work_queue->write(0 * bl.length(), bl.length(), - bufferlist{bl}, 0)); + api::Io<>::write(*m_src_ictx, 0 * bl.length(), bl.length(), + bufferlist{bl}, 0)); ASSERT_EQ(static_cast(bl.length()), - m_src_ictx->io_work_queue->write(2 * bl.length(), bl.length(), - bufferlist{bl}, 0)); - ASSERT_EQ(0, m_src_ictx->io_work_queue->flush()); + api::Io<>::write(*m_src_ictx, 2 * bl.length(), bl.length(), + bufferlist{bl}, 0)); + ASSERT_EQ(0, api::Io<>::flush(*m_src_ictx)); ASSERT_EQ(0, snap_create(*m_src_ictx, "snap")); ASSERT_EQ(0, snap_protect(*m_src_ictx, "snap")); @@ -330,12 +329,12 @@ struct TestDeepCopy : public TestFixture { bufferlist bl1; bl1.append(std::string(1000, 'X')); ASSERT_EQ(static_cast(bl1.length()), - m_src_ictx->io_work_queue->write(0 * bl.length(), bl1.length(), - bufferlist{bl1}, 0)); + api::Io<>::write(*m_src_ictx, 0 * bl.length(), bl1.length(), + bufferlist{bl1}, 0)); ASSERT_EQ(static_cast(bl1.length()), - m_src_ictx->io_work_queue->discard(bl1.length() + 10, - bl1.length(), false)); - ASSERT_EQ(0, m_src_ictx->io_work_queue->flush()); + api::Io<>::discard(*m_src_ictx, bl1.length() + 10, + bl1.length(), false)); + ASSERT_EQ(0, api::Io<>::flush(*m_src_ictx)); ASSERT_EQ(0, snap_create(*m_src_ictx, "snap")); ASSERT_EQ(0, snap_protect(*m_src_ictx, "snap")); @@ -348,11 +347,11 @@ struct TestDeepCopy : public TestFixture { ASSERT_EQ(0, open_image(clone_name, &m_src_ictx)); ASSERT_EQ(static_cast(bl1.length()), - m_src_ictx->io_work_queue->write(1 * bl.length(), bl1.length(), - bufferlist{bl1}, 0)); + api::Io<>::write(*m_src_ictx, 1 * bl.length(), bl1.length(), + bufferlist{bl1}, 0)); ASSERT_EQ(static_cast(bl1.length()), - m_src_ictx->io_work_queue->discard(2 * bl1.length() + 10, - bl1.length(), false)); + api::Io<>::discard(*m_src_ictx, 2 * bl1.length() + 10, + bl1.length(), false)); } void test_stress() { @@ -387,18 +386,18 @@ struct TestDeepCopy : public TestFixture { std::cout << "write: " << static_cast('A' + i) << " " << off << "~" << len << std::endl; ASSERT_EQ(static_cast(bl.length()), - m_src_ictx->io_work_queue->write(off, bl.length(), - bufferlist{bl}, 0)); + api::Io<>::write(*m_src_ictx, off, bl.length(), + bufferlist{bl}, 0)); len = rand() % ((1 << m_src_ictx->order) * 2); ASSERT_GT(size, len); off = std::min(static_cast(rand() % size), static_cast(size - len)); std::cout << "discard: " << off << "~" << len << std::endl; ASSERT_EQ(static_cast(len), - m_src_ictx->io_work_queue->discard(off, len, false)); + api::Io<>::discard(*m_src_ictx, off, len, false)); } - ASSERT_EQ(0, m_src_ictx->io_work_queue->flush()); + ASSERT_EQ(0, api::Io<>::flush(*m_src_ictx)); std::string snap_name = "snap" + stringify(i); std::cout << "snap: " << snap_name << std::endl; @@ -757,3 +756,5 @@ TEST_F(TestDeepCopy, Stress_StrippingSmallerDstObjSize) test_stress(); } + +} // namespace librbd diff --git a/src/test/librbd/test_Migration.cc b/src/test/librbd/test_Migration.cc index 19512036ad3..f6a631a9070 100644 --- a/src/test/librbd/test_Migration.cc +++ b/src/test/librbd/test_Migration.cc @@ -8,6 +8,7 @@ #include "librbd/Operations.h" #include "librbd/api/Group.h" #include "librbd/api/Image.h" +#include "librbd/api/Io.h" #include "librbd/api/Migration.h" #include "librbd/api/Mirror.h" #include "librbd/api/Namespace.h" @@ -15,7 +16,6 @@ #include "librbd/image/AttachChildRequest.h" #include "librbd/image/AttachParentRequest.h" #include "librbd/internal.h" -#include "librbd/io/ImageRequestWQ.h" #include "librbd/io/ReadResult.h" #include "common/Cond.h" #include @@ -23,6 +23,8 @@ void register_test_migration() { } +namespace librbd { + struct TestMigration : public TestFixture { static void SetUpTestCase() { TestFixture::SetUpTestCase(); @@ -126,15 +128,17 @@ struct TestMigration : public TestFixture { bufferlist src_bl; src_bl.push_back(src_ptr); librbd::io::ReadResult src_result{&src_bl}; - EXPECT_EQ(read_size, src_ictx->io_work_queue->read( - offset, read_size, librbd::io::ReadResult{src_result}, 0)); + EXPECT_EQ(read_size, api::Io<>::read( + *src_ictx, offset, read_size, + librbd::io::ReadResult{src_result}, 0)); bufferptr dst_ptr(read_size); bufferlist dst_bl; dst_bl.push_back(dst_ptr); librbd::io::ReadResult dst_result{&dst_bl}; - EXPECT_EQ(read_size, dst_ictx->io_work_queue->read( - offset, read_size, librbd::io::ReadResult{dst_result}, 0)); + EXPECT_EQ(read_size, api::Io<>::read( + *dst_ictx, offset, read_size, + librbd::io::ReadResult{dst_result}, 0)); if (!src_bl.contents_equal(dst_bl)) { std::cout << description @@ -250,25 +254,25 @@ struct TestMigration : public TestFixture { bufferlist ref_bl; ref_bl.append(std::string(len, c)); ASSERT_EQ(static_cast(len), - m_ref_ictx->io_work_queue->write(off, len, std::move(ref_bl), 0)); + api::Io<>::write(*m_ref_ictx, off, len, std::move(ref_bl), 0)); bufferlist bl; bl.append(std::string(len, c)); ASSERT_EQ(static_cast(len), - m_ictx->io_work_queue->write(off, len, std::move(bl), 0)); + api::Io<>::write(*m_ictx, off, len, std::move(bl), 0)); } void discard(uint64_t off, uint64_t len) { std::cout << "discard: " << off << "~" << len << std::endl; ASSERT_EQ(static_cast(len), - m_ref_ictx->io_work_queue->discard(off, len, false)); + api::Io<>::discard(*m_ref_ictx, off, len, false)); ASSERT_EQ(static_cast(len), - m_ictx->io_work_queue->discard(off, len, false)); + api::Io<>::discard(*m_ictx, off, len, false)); } void flush() { - ASSERT_EQ(0, m_ref_ictx->io_work_queue->flush()); - ASSERT_EQ(0, m_ictx->io_work_queue->flush()); + ASSERT_EQ(0, api::Io<>::flush(*m_ref_ictx)); + ASSERT_EQ(0, api::Io<>::flush(*m_ictx)); } void snap_create(const std::string &snap_name) { @@ -424,8 +428,8 @@ struct TestMigration : public TestFixture { bufferptr ptr(10); bl.push_back(ptr); librbd::io::ReadResult result{&bl}; - ASSERT_EQ(10, child_ictx->io_work_queue->read( - 0, 10, librbd::io::ReadResult{result}, 0)); + ASSERT_EQ(10, api::Io<>::read( + *child_ictx, 0, 10, librbd::io::ReadResult{result}, 0)); bufferlist ref_bl; ref_bl.append(std::string(10, 'A')); ASSERT_TRUE(ref_bl.contents_equal(bl)); @@ -1324,3 +1328,5 @@ TEST_F(TestMigration, StressLive) { test_stress2(true); } + +} // namespace librbd diff --git a/src/test/librbd/test_fixture.cc b/src/test/librbd/test_fixture.cc index 4e9d2b6497f..82c6e6d2781 100644 --- a/src/test/librbd/test_fixture.cc +++ b/src/test/librbd/test_fixture.cc @@ -7,7 +7,7 @@ #include "librbd/ImageState.h" #include "librbd/ImageWatcher.h" #include "librbd/Operations.h" -#include "librbd/io/ImageRequestWQ.h" +#include "librbd/api/Io.h" #include "cls/lock/cls_lock_client.h" #include "cls/lock/cls_lock_types.h" #include "cls/rbd/cls_rbd_types.h" @@ -134,7 +134,7 @@ int TestFixture::unlock_image() { } int TestFixture::acquire_exclusive_lock(librbd::ImageCtx &ictx) { - int r = ictx.io_work_queue->write(0, 0, {}, 0); + int r = librbd::api::Io<>::write(ictx, 0, 0, {}, 0); if (r != 0) { return r; } diff --git a/src/test/librbd/test_internal.cc b/src/test/librbd/test_internal.cc index 26cea7e06a0..4d455de0773 100644 --- a/src/test/librbd/test_internal.cc +++ b/src/test/librbd/test_internal.cc @@ -15,12 +15,12 @@ #include "librbd/Operations.h" #include "librbd/api/DiffIterate.h" #include "librbd/api/Image.h" +#include "librbd/api/Io.h" #include "librbd/api/Migration.h" #include "librbd/api/PoolMetadata.h" #include "librbd/api/Snapshot.h" #include "librbd/io/AioCompletion.h" #include "librbd/io/ImageRequest.h" -#include "librbd/io/ImageRequestWQ.h" #include "osdc/Striper.h" #include "common/Cond.h" #include @@ -32,6 +32,8 @@ void register_test_internal() { } +namespace librbd { + class TestInternal : public TestFixture { public: @@ -386,7 +388,7 @@ TEST_F(TestInternal, AioWriteRequestsLock) { bufferlist bl; bl.append(buffer); - ictx->io_work_queue->aio_write(c, 0, buffer.size(), std::move(bl), 0); + api::Io<>::aio_write(*ictx, c, 0, buffer.size(), std::move(bl), 0, true); bool is_owner; ASSERT_EQ(0, librbd::is_exclusive_lock_owner(ictx, &is_owner)); @@ -408,7 +410,7 @@ TEST_F(TestInternal, AioDiscardRequestsLock) { Context *ctx = new DummyContext(); auto c = librbd::io::AioCompletion::create(ctx); c->get(); - ictx->io_work_queue->aio_discard(c, 0, 256, false); + api::Io<>::aio_discard(*ictx, c, 0, 256, false, true); bool is_owner; ASSERT_EQ(0, librbd::is_exclusive_lock_owner(ictx, &is_owner)); @@ -583,9 +585,9 @@ TEST_F(TestInternal, SnapshotCopyup) bufferlist bl; bl.append(std::string(256, '1')); - ASSERT_EQ(256, ictx->io_work_queue->write(0, bl.length(), bufferlist{bl}, 0)); - ASSERT_EQ(256, ictx->io_work_queue->write(1024, bl.length(), bufferlist{bl}, - 0)); + ASSERT_EQ(256, api::Io<>::write(*ictx, 0, bl.length(), bufferlist{bl}, 0)); + ASSERT_EQ(256, api::Io<>::write(*ictx, 1024, bl.length(), bufferlist{bl}, + 0)); ASSERT_EQ(0, snap_create(*ictx, "snap1")); ASSERT_EQ(0, @@ -606,8 +608,8 @@ TEST_F(TestInternal, SnapshotCopyup) ASSERT_EQ(0, snap_create(*ictx2, "snap1")); ASSERT_EQ(0, snap_create(*ictx2, "snap2")); - ASSERT_EQ(256, ictx2->io_work_queue->write(256, bl.length(), bufferlist{bl}, - 0)); + ASSERT_EQ(256, api::Io<>::write(*ictx2, 256, bl.length(), bufferlist{bl}, + 0)); librados::IoCtx snap_ctx; snap_ctx.dup(ictx2->data_ctx); @@ -640,21 +642,18 @@ TEST_F(TestInternal, SnapshotCopyup) ictx2, cls::rbd::UserSnapshotNamespace(), snap_name)); ASSERT_EQ(256, - ictx2->io_work_queue->read(0, 256, - librbd::io::ReadResult{read_result}, - 0)); + api::Io<>::read(*ictx2, 0, 256, + librbd::io::ReadResult{read_result}, 0)); ASSERT_TRUE(bl.contents_equal(read_bl)); ASSERT_EQ(256, - ictx2->io_work_queue->read(1024, 256, - librbd::io::ReadResult{read_result}, - 0)); + api::Io<>::read(*ictx2, 1024, 256, + librbd::io::ReadResult{read_result}, 0)); ASSERT_TRUE(bl.contents_equal(read_bl)); ASSERT_EQ(256, - ictx2->io_work_queue->read(256, 256, - librbd::io::ReadResult{read_result}, - 0)); + api::Io<>::read(*ictx2, 256, 256, + librbd::io::ReadResult{read_result}, 0)); if (snap_name == NULL) { ASSERT_TRUE(bl.contents_equal(read_bl)); } else { @@ -699,9 +698,8 @@ TEST_F(TestInternal, SnapshotCopyup) std::map read_m; librbd::io::ReadResult sparse_read_result{&read_m, &read_bl}; EXPECT_EQ(1024 + 256, - ictx3->io_work_queue->read(0, 1024 + 256, - librbd::io::ReadResult{sparse_read_result}, - 0)); + api::Io<>::read(*ictx3, 0, 1024 + 256, + librbd::io::ReadResult{sparse_read_result}, 0)); EXPECT_EQ(expected_m, read_m); EXPECT_TRUE(expected_bl.contents_equal(read_bl)); } @@ -754,8 +752,8 @@ TEST_F(TestInternal, SnapshotCopyupZeros) bufferlist bl; bl.append(std::string(256, '1')); - ASSERT_EQ(256, ictx2->io_work_queue->write(256, bl.length(), bufferlist{bl}, - 0)); + ASSERT_EQ(256, api::Io<>::write(*ictx2, 256, bl.length(), bufferlist{bl}, + 0)); librados::IoCtx snap_ctx; snap_ctx.dup(ictx2->data_ctx); @@ -781,15 +779,13 @@ TEST_F(TestInternal, SnapshotCopyupZeros) ictx2, cls::rbd::UserSnapshotNamespace(), snap_name)); ASSERT_EQ(256, - ictx2->io_work_queue->read(0, 256, - librbd::io::ReadResult{read_result}, - 0)); + api::Io<>::read(*ictx2, 0, 256, + librbd::io::ReadResult{read_result}, 0)); ASSERT_TRUE(read_bl.is_zero()); ASSERT_EQ(256, - ictx2->io_work_queue->read(256, 256, - librbd::io::ReadResult{read_result}, - 0)); + api::Io<>::read(*ictx2, 256, 256, + librbd::io::ReadResult{read_result}, 0)); if (snap_name == NULL) { ASSERT_TRUE(bl.contents_equal(read_bl)); } else { @@ -842,8 +838,7 @@ TEST_F(TestInternal, SnapshotCopyupZerosMigration) bufferlist bl; bl.append(std::string(256, '1')); - ASSERT_EQ(256, ictx2->io_work_queue->write(256, bl.length(), bufferlist{bl}, - 0)); + ASSERT_EQ(256, api::Io<>::write(*ictx2, 256, bl.length(), bufferlist{bl}, 0)); librados::IoCtx snap_ctx; snap_ctx.dup(ictx2->data_ctx); @@ -869,15 +864,13 @@ TEST_F(TestInternal, SnapshotCopyupZerosMigration) ictx2, cls::rbd::UserSnapshotNamespace(), snap_name)); ASSERT_EQ(256, - ictx2->io_work_queue->read(0, 256, - librbd::io::ReadResult{read_result}, - 0)); + api::Io<>::read(*ictx2, 0, 256, + librbd::io::ReadResult{read_result}, 0)); ASSERT_TRUE(read_bl.is_zero()); ASSERT_EQ(256, - ictx2->io_work_queue->read(256, 256, - librbd::io::ReadResult{read_result}, - 0)); + api::Io<>::read(*ictx2, 256, 256, + librbd::io::ReadResult{read_result}, 0)); if (snap_name == NULL) { ASSERT_TRUE(bl.contents_equal(read_bl)); } else { @@ -911,7 +904,7 @@ TEST_F(TestInternal, ResizeCopyup) m_image_size = 1 << 14; uint64_t features = 0; - get_features(&features); + ::get_features(&features); int order = 12; ASSERT_EQ(0, m_rbd.create2(m_ioctx, m_image_name.c_str(), m_image_size, features, &order)); @@ -923,8 +916,7 @@ TEST_F(TestInternal, ResizeCopyup) bl.append(std::string(4096, '1')); for (size_t i = 0; i < m_image_size; i += bl.length()) { ASSERT_EQ((ssize_t)bl.length(), - ictx->io_work_queue->write(i, bl.length(), - bufferlist{bl}, 0)); + api::Io<>::write(*ictx, i, bl.length(), bufferlist{bl}, 0)); } ASSERT_EQ(0, snap_create(*ictx, "snap1")); @@ -963,9 +955,8 @@ TEST_F(TestInternal, ResizeCopyup) librbd::io::ReadResult read_result{&read_bl}; for (size_t i = 2 << order; i < m_image_size; i += bl.length()) { ASSERT_EQ((ssize_t)bl.length(), - ictx2->io_work_queue->read(i, bl.length(), - librbd::io::ReadResult{read_result}, - 0)); + api::Io<>::read(*ictx2, i, bl.length(), + librbd::io::ReadResult{read_result}, 0)); ASSERT_TRUE(bl.contents_equal(read_bl)); } } @@ -981,7 +972,7 @@ TEST_F(TestInternal, DiscardCopyup) m_image_size = 1 << 14; uint64_t features = 0; - get_features(&features); + ::get_features(&features); int order = 12; ASSERT_EQ(0, m_rbd.create2(m_ioctx, m_image_name.c_str(), m_image_size, features, &order)); @@ -993,8 +984,7 @@ TEST_F(TestInternal, DiscardCopyup) bl.append(std::string(4096, '1')); for (size_t i = 0; i < m_image_size; i += bl.length()) { ASSERT_EQ((ssize_t)bl.length(), - ictx->io_work_queue->write(i, bl.length(), - bufferlist{bl}, 0)); + api::Io<>::write(*ictx, i, bl.length(), bufferlist{bl}, 0)); } ASSERT_EQ(0, snap_create(*ictx, "snap1")); @@ -1016,7 +1006,7 @@ TEST_F(TestInternal, DiscardCopyup) read_bl.push_back(read_ptr); ASSERT_EQ(static_cast(m_image_size - 64), - ictx2->io_work_queue->discard(32, m_image_size - 64, false)); + api::Io<>::discard(*ictx2, 32, m_image_size - 64, false)); ASSERT_EQ(0, librbd::api::Image<>::snap_set(ictx2, cls::rbd::UserSnapshotNamespace(), "snap1")); @@ -1030,9 +1020,8 @@ TEST_F(TestInternal, DiscardCopyup) librbd::io::ReadResult read_result{&read_bl}; for (size_t i = 0; i < m_image_size; i += bl.length()) { ASSERT_EQ((ssize_t)bl.length(), - ictx2->io_work_queue->read(i, bl.length(), - librbd::io::ReadResult{read_result}, - 0)); + api::Io<>::read(*ictx2, i, bl.length(), + librbd::io::ReadResult{read_result}, 0)); ASSERT_TRUE(bl.contents_equal(read_bl)); } } @@ -1046,12 +1035,13 @@ TEST_F(TestInternal, ShrinkFlushesCache) { // ensure write-path is initialized bufferlist write_bl; write_bl.append(buffer); - ictx->io_work_queue->write(0, buffer.size(), bufferlist{write_bl}, 0); + api::Io<>::write(*ictx, 0, buffer.size(), bufferlist{write_bl}, 0); C_SaferCond cond_ctx; auto c = librbd::io::AioCompletion::create(&cond_ctx); c->get(); - ictx->io_work_queue->aio_write(c, 0, buffer.size(), bufferlist{write_bl}, 0); + api::Io<>::aio_write(*ictx, c, 0, buffer.size(), bufferlist{write_bl}, 0, + true); librbd::NoOpProgressContext no_op; ASSERT_EQ(0, ictx->operations->resize(m_image_size >> 1, true, no_op)); @@ -1141,8 +1131,8 @@ TEST_F(TestInternal, WriteFullCopyup) { bufferlist bl; bl.append(std::string(1 << ictx->order, '1')); ASSERT_EQ((ssize_t)bl.length(), - ictx->io_work_queue->write(0, bl.length(), bufferlist{bl}, 0)); - ASSERT_EQ(0, ictx->io_work_queue->flush()); + api::Io<>::write(*ictx, 0, bl.length(), bufferlist{bl}, 0)); + ASSERT_EQ(0, api::Io<>::flush(*ictx)); ASSERT_EQ(0, create_snapshot("snap1", true)); @@ -1172,8 +1162,8 @@ TEST_F(TestInternal, WriteFullCopyup) { bufferlist write_full_bl; write_full_bl.append(std::string(1 << ictx2->order, '2')); ASSERT_EQ((ssize_t)write_full_bl.length(), - ictx2->io_work_queue->write(0, write_full_bl.length(), - bufferlist{write_full_bl}, 0)); + api::Io<>::write(*ictx2, 0, write_full_bl.length(), + bufferlist{write_full_bl}, 0)); ASSERT_EQ(0, ictx2->operations->flatten(no_op)); @@ -1183,16 +1173,16 @@ TEST_F(TestInternal, WriteFullCopyup) { librbd::io::ReadResult read_result{&read_bl}; ASSERT_EQ((ssize_t)read_bl.length(), - ictx2->io_work_queue->read(0, read_bl.length(), - librbd::io::ReadResult{read_result}, 0)); + api::Io<>::read(*ictx2, 0, read_bl.length(), + librbd::io::ReadResult{read_result}, 0)); ASSERT_TRUE(write_full_bl.contents_equal(read_bl)); ASSERT_EQ(0, librbd::api::Image<>::snap_set(ictx2, cls::rbd::UserSnapshotNamespace(), "snap1")); ASSERT_EQ((ssize_t)read_bl.length(), - ictx2->io_work_queue->read(0, read_bl.length(), - librbd::io::ReadResult{read_result}, 0)); + api::Io<>::read(*ictx2, 0, read_bl.length(), + librbd::io::ReadResult{read_result}, 0)); ASSERT_TRUE(bl.contents_equal(read_bl)); } @@ -1268,7 +1258,7 @@ TEST_F(TestInternal, TestCoR) int order = 12; // smallest object size is 4K uint64_t features; - ASSERT_TRUE(get_features(&features)); + ASSERT_TRUE(::get_features(&features)); ASSERT_EQ(0, create_image_full_pp(m_rbd, m_ioctx, m_image_name, m_image_size, features, false, &order)); @@ -1410,7 +1400,7 @@ TEST_F(TestInternal, FlattenNoEmptyObjects) int order = 12; // smallest object size is 4K uint64_t features; - ASSERT_TRUE(get_features(&features)); + ASSERT_TRUE(::get_features(&features)); ASSERT_EQ(0, create_image_full_pp(m_rbd, m_ioctx, m_image_name, m_image_size, features, false, &order)); @@ -1558,7 +1548,7 @@ TEST_F(TestInternal, PoolMetadataConfApply) { std::string image_name = get_temp_image_name(); int order = 0; uint64_t features; - ASSERT_TRUE(get_features(&features)); + ASSERT_TRUE(::get_features(&features)); ASSERT_EQ(0, create_image_full_pp(m_rbd, m_ioctx, image_name, m_image_size, features, false, &order)); @@ -1618,27 +1608,27 @@ TEST_F(TestInternal, Sparsify) { bl.append(std::string(4096, '\0')); ASSERT_EQ((ssize_t)bl.length(), - ictx->io_work_queue->write(0, bl.length(), bufferlist{bl}, 0)); + api::Io<>::write(*ictx, 0, bl.length(), bufferlist{bl}, 0)); ASSERT_EQ((ssize_t)bl.length(), - ictx->io_work_queue->write((1 << ictx->order) * 1 + 512, - bl.length(), bufferlist{bl}, 0)); + api::Io<>::write(*ictx, (1 << ictx->order) * 1 + 512, + bl.length(), bufferlist{bl}, 0)); bl.append(std::string(4096, '1')); bl.append(std::string(4096, '\0')); bl.append(std::string(4096, '2')); bl.append(std::string(4096 - 1, '\0')); ASSERT_EQ((ssize_t)bl.length(), - ictx->io_work_queue->write((1 << ictx->order) * 10, bl.length(), - bufferlist{bl}, 0)); + api::Io<>::write(*ictx, (1 << ictx->order) * 10, bl.length(), + bufferlist{bl}, 0)); bufferlist bl2; bl2.append(std::string(4096 - 1, '\0')); ASSERT_EQ((ssize_t)bl2.length(), - ictx->io_work_queue->write((1 << ictx->order) * 10 + 4096 * 10, - bl2.length(), bufferlist{bl2}, 0)); + api::Io<>::write(*ictx, (1 << ictx->order) * 10 + 4096 * 10, + bl2.length(), bufferlist{bl2}, 0)); - ASSERT_EQ(0, ictx->io_work_queue->flush()); + ASSERT_EQ(0, api::Io<>::flush(*ictx)); ASSERT_EQ(0, ictx->operations->sparsify(4096, no_op)); @@ -1648,8 +1638,8 @@ TEST_F(TestInternal, Sparsify) { librbd::io::ReadResult read_result{&read_bl}; ASSERT_EQ((ssize_t)read_bl.length(), - ictx->io_work_queue->read((1 << ictx->order) * 10, read_bl.length(), - librbd::io::ReadResult{read_result}, 0)); + api::Io<>::read(*ictx, (1 << ictx->order) * 10, read_bl.length(), + librbd::io::ReadResult{read_result}, 0)); ASSERT_TRUE(bl.contents_equal(read_bl)); std::string oid = ictx->get_object_name(0); @@ -1717,16 +1707,16 @@ TEST_F(TestInternal, SparsifyClone) { bl.append(std::string(4096, '\0')); ASSERT_EQ((ssize_t)bl.length(), - ictx->io_work_queue->write(0, bl.length(), bufferlist{bl}, 0)); + api::Io<>::write(*ictx, 0, bl.length(), bufferlist{bl}, 0)); bl.append(std::string(4096, '1')); bl.append(std::string(4096, '\0')); bl.append(std::string(4096, '2')); bl.append(std::string(4096, '\0')); ASSERT_EQ((ssize_t)bl.length(), - ictx->io_work_queue->write((1 << ictx->order) * 10, bl.length(), - bufferlist{bl}, 0)); - ASSERT_EQ(0, ictx->io_work_queue->flush()); + api::Io<>::write(*ictx, (1 << ictx->order) * 10, bl.length(), + bufferlist{bl}, 0)); + ASSERT_EQ(0, api::Io<>::flush(*ictx)); ASSERT_EQ(0, ictx->operations->sparsify(4096, no_op)); @@ -1736,8 +1726,8 @@ TEST_F(TestInternal, SparsifyClone) { librbd::io::ReadResult read_result{&read_bl}; ASSERT_EQ((ssize_t)read_bl.length(), - ictx->io_work_queue->read((1 << ictx->order) * 10, read_bl.length(), - librbd::io::ReadResult{read_result}, 0)); + api::Io<>::read(*ictx, (1 << ictx->order) * 10, read_bl.length(), + librbd::io::ReadResult{read_result}, 0)); ASSERT_TRUE(bl.contents_equal(read_bl)); std::string oid = ictx->get_object_name(0); @@ -1786,20 +1776,19 @@ TEST_F(TestInternal, MissingDataPool) { read_bl.push_back(read_ptr); librbd::io::ReadResult read_result{&read_bl}; ASSERT_EQ(-ENODEV, - ictx->io_work_queue->read(0, 256, - librbd::io::ReadResult{read_result}, 0)); + api::Io<>::read(*ictx, 0, 256, + librbd::io::ReadResult{read_result}, 0)); ASSERT_EQ(-ENODEV, - ictx->io_work_queue->write(0, bl.length(), bufferlist{bl}, 0)); - ASSERT_EQ(-ENODEV, ictx->io_work_queue->discard(0, 1, 256)); + api::Io<>::write(*ictx, 0, bl.length(), bufferlist{bl}, 0)); + ASSERT_EQ(-ENODEV, api::Io<>::discard(*ictx, 0, 1, 256)); ASSERT_EQ(-ENODEV, - ictx->io_work_queue->writesame(0, bl.length(), bufferlist{bl}, 0)); + api::Io<>::write_same(*ictx, 0, bl.length(), bufferlist{bl}, 0)); uint64_t mismatch_off; ASSERT_EQ(-ENODEV, - ictx->io_work_queue->compare_and_write(0, bl.length(), - bufferlist{bl}, - bufferlist{bl}, - &mismatch_off, 0)); - ASSERT_EQ(-ENODEV, ictx->io_work_queue->flush()); + api::Io<>::compare_and_write(*ictx, 0, bl.length(), + bufferlist{bl}, bufferlist{bl}, + &mismatch_off, 0)); + ASSERT_EQ(-ENODEV, api::Io<>::flush(*ictx)); ASSERT_EQ(-ENODEV, snap_create(*ictx, "snap2")); ASSERT_EQ(0, ictx->operations->snap_remove(cls::rbd::UserSnapshotNamespace(), @@ -1814,3 +1803,5 @@ TEST_F(TestInternal, MissingDataPool) { ASSERT_EQ(0, create_image_pp(m_rbd, m_ioctx, m_image_name, m_image_size)); } + +} // namespace librbd diff --git a/src/test/rbd_mirror/test_ImageReplayer.cc b/src/test/rbd_mirror/test_ImageReplayer.cc index 69dabbb7bcb..4498c7bef3a 100644 --- a/src/test/rbd_mirror/test_ImageReplayer.cc +++ b/src/test/rbd_mirror/test_ImageReplayer.cc @@ -31,10 +31,10 @@ #include "librbd/Operations.h" #include "librbd/Utils.h" #include "librbd/internal.h" +#include "librbd/api/Io.h" #include "librbd/api/Mirror.h" #include "librbd/api/Snapshot.h" #include "librbd/io/AioCompletion.h" -#include "librbd/io/ImageRequestWQ.h" #include "librbd/io/ReadResult.h" #include "tools/rbd_mirror/ImageReplayer.h" #include "tools/rbd_mirror/InstanceWatcher.h" @@ -489,7 +489,7 @@ public: size_t written; bufferlist bl; bl.append(std::string(test_data, len)); - written = ictx->io_work_queue->write(off, len, std::move(bl), 0); + written = librbd::api::Io<>::write(*ictx, off, len, std::move(bl), 0); printf("wrote: %d\n", (int)written); ASSERT_EQ(len, written); } @@ -501,8 +501,8 @@ public: char *result = (char *)malloc(len + 1); ASSERT_NE(static_cast(NULL), result); - read = ictx->io_work_queue->read( - off, len, librbd::io::ReadResult{result, len}, 0); + read = librbd::api::Io<>::read( + *ictx, off, len, librbd::io::ReadResult{result, len}, 0); printf("read: %d\n", (int)read); ASSERT_EQ(len, static_cast(read)); result[len] = '\0'; @@ -525,7 +525,7 @@ public: C_SaferCond aio_flush_ctx; auto c = librbd::io::AioCompletion::create(&aio_flush_ctx); c->get(); - ictx->io_work_queue->aio_flush(c); + librbd::api::Io<>::aio_flush(*ictx, c, true); ASSERT_EQ(0, c->wait_for_complete()); c->put(); diff --git a/src/test/rbd_mirror/test_ImageSync.cc b/src/test/rbd_mirror/test_ImageSync.cc index 7587760c25f..7415fff2fa9 100644 --- a/src/test/rbd_mirror/test_ImageSync.cc +++ b/src/test/rbd_mirror/test_ImageSync.cc @@ -12,9 +12,9 @@ #include "librbd/ImageState.h" #include "librbd/internal.h" #include "librbd/Operations.h" +#include "librbd/api/Io.h" #include "librbd/io/AioCompletion.h" #include "librbd/io/ImageDispatchSpec.h" -#include "librbd/io/ImageRequestWQ.h" #include "librbd/io/ReadResult.h" #include "librbd/journal/Types.h" #include "tools/rbd_mirror/ImageSync.h" @@ -51,13 +51,13 @@ void scribble(librbd::ImageCtx *image_ctx, int num_ops, uint64_t max_size) if (rand() % 4 == 0) { ASSERT_EQ((int)len, - image_ctx->io_work_queue->discard( - off, len, image_ctx->discard_granularity_bytes)); + librbd::api::Io<>::discard( + *image_ctx, off, len, image_ctx->discard_granularity_bytes)); } else { bufferlist bl; bl.append(std::string(len, '1')); - ASSERT_EQ((int)len, image_ctx->io_work_queue->write(off, len, - std::move(bl), 0)); + ASSERT_EQ((int)len, librbd::api::Io<>::write( + *image_ctx, off, len, std::move(bl), 0)); } } @@ -175,11 +175,11 @@ TEST_F(TestImageSync, Simple) { for (uint64_t offset = 0; offset < m_remote_image_ctx->size; offset += object_size) { - ASSERT_LE(0, m_remote_image_ctx->io_work_queue->read( - offset, object_size, + ASSERT_LE(0, librbd::api::Io<>::read( + *m_remote_image_ctx, offset, object_size, librbd::io::ReadResult{&read_remote_bl}, 0)); - ASSERT_LE(0, m_local_image_ctx->io_work_queue->read( - offset, object_size, + ASSERT_LE(0, librbd::api::Io<>::read( + *m_local_image_ctx, offset, object_size, librbd::io::ReadResult{&read_local_bl}, 0)); ASSERT_TRUE(read_remote_bl.contents_equal(read_local_bl)); } @@ -194,9 +194,8 @@ TEST_F(TestImageSync, Resize) { bufferlist bl; bl.append(std::string(len, '1')); - ASSERT_EQ((int)len, m_remote_image_ctx->io_work_queue->write(off, len, - std::move(bl), - 0)); + ASSERT_EQ((int)len, librbd::api::Io<>::write( + *m_remote_image_ctx, off, len, std::move(bl), 0)); { std::shared_lock owner_locker{m_remote_image_ctx->owner_lock}; ASSERT_EQ(0, flush(m_remote_image_ctx)); @@ -219,10 +218,12 @@ TEST_F(TestImageSync, Resize) { bufferlist read_local_bl; read_local_bl.append(std::string(len, '\0')); - ASSERT_LE(0, m_remote_image_ctx->io_work_queue->read( - off, len, librbd::io::ReadResult{&read_remote_bl}, 0)); - ASSERT_LE(0, m_local_image_ctx->io_work_queue->read( - off, len, librbd::io::ReadResult{&read_local_bl}, 0)); + ASSERT_LE(0, librbd::api::Io<>::read( + *m_remote_image_ctx, off, len, + librbd::io::ReadResult{&read_remote_bl}, 0)); + ASSERT_LE(0, librbd::api::Io<>::read( + *m_local_image_ctx, off, len, + librbd::io::ReadResult{&read_local_bl}, 0)); ASSERT_TRUE(read_remote_bl.contents_equal(read_local_bl)); } @@ -236,9 +237,8 @@ TEST_F(TestImageSync, Discard) { bufferlist bl; bl.append(std::string(len, '1')); - ASSERT_EQ((int)len, m_remote_image_ctx->io_work_queue->write(off, len, - std::move(bl), - 0)); + ASSERT_EQ((int)len, librbd::api::Io<>::write( + *m_remote_image_ctx, off, len, std::move(bl), 0)); { std::shared_lock owner_locker{m_remote_image_ctx->owner_lock}; ASSERT_EQ(0, flush(m_remote_image_ctx)); @@ -247,8 +247,9 @@ TEST_F(TestImageSync, Discard) { ASSERT_EQ(0, create_snap(m_remote_image_ctx, "snap", nullptr)); ASSERT_EQ((int)len - 2, - m_remote_image_ctx->io_work_queue->discard( - off + 1, len - 2, m_remote_image_ctx->discard_granularity_bytes)); + librbd::api::Io<>::discard( + *m_remote_image_ctx, off + 1, len - 2, + m_remote_image_ctx->discard_granularity_bytes)); { std::shared_lock owner_locker{m_remote_image_ctx->owner_lock}; ASSERT_EQ(0, flush(m_remote_image_ctx)); @@ -264,10 +265,12 @@ TEST_F(TestImageSync, Discard) { bufferlist read_local_bl; read_local_bl.append(std::string(object_size, '\0')); - ASSERT_LE(0, m_remote_image_ctx->io_work_queue->read( - off, len, librbd::io::ReadResult{&read_remote_bl}, 0)); - ASSERT_LE(0, m_local_image_ctx->io_work_queue->read( - off, len, librbd::io::ReadResult{&read_local_bl}, 0)); + ASSERT_LE(0, librbd::api::Io<>::read( + *m_remote_image_ctx, off, len, + librbd::io::ReadResult{&read_remote_bl}, 0)); + ASSERT_LE(0, librbd::api::Io<>::read( + *m_local_image_ctx, off, len, + librbd::io::ReadResult{&read_local_bl}, 0)); ASSERT_TRUE(read_remote_bl.contents_equal(read_local_bl)); } @@ -352,11 +355,11 @@ TEST_F(TestImageSync, SnapshotStress) { ASSERT_EQ(remote_size, local_size); for (uint64_t offset = 0; offset < remote_size; offset += object_size) { - ASSERT_LE(0, m_remote_image_ctx->io_work_queue->read( - offset, object_size, + ASSERT_LE(0, librbd::api::Io<>::read( + *m_remote_image_ctx, offset, object_size, librbd::io::ReadResult{&read_remote_bl}, 0)); - ASSERT_LE(0, m_local_image_ctx->io_work_queue->read( - offset, object_size, + ASSERT_LE(0, librbd::api::Io<>::read( + *m_local_image_ctx, offset, object_size, librbd::io::ReadResult{&read_local_bl}, 0)); ASSERT_TRUE(read_remote_bl.contents_equal(read_local_bl)); } -- 2.47.3