#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
explicit FlushCacheCommand(ImageCtx *ictx) : ictx(ictx) {}
int call(Formatter *f) override {
- return ictx->io_work_queue->flush();
+ return api::Io<>::flush(*ictx);
}
private:
#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"
#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"
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;
}
#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
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 <typename I>
void ImageDispatch<I>::shut_down(Context* on_finish) {
on_finish->complete(0);
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<I>::aio_read(
m_image_ctx, aio_comp, std::move(image_extents), std::move(read_result),
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<I>::aio_write(
m_image_ctx, aio_comp, std::move(image_extents), std::move(bl), op_flags,
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<I>::aio_discard(
m_image_ctx, aio_comp, std::move(image_extents), discard_granularity_bytes,
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<I>::aio_writesame(
m_image_ctx, aio_comp, std::move(image_extents), std::move(bl), op_flags,
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<I>::aio_compare_and_write(
m_image_ctx, aio_comp, std::move(image_extents), std::move(cmp_bl),
auto cct = m_image_ctx->cct;
ldout(cct, 20) << dendl;
+ start_in_flight_io(aio_comp);
+
*dispatch_result = DISPATCH_RESULT_COMPLETE;
ImageRequest<I>::aio_flush(m_image_ctx, aio_comp, flush_source, parent_trace);
return true;
#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"
#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 <algorithm>
#include <string>
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;
}
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;
}
{
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;
{
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;
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;
}
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;
}
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;
}
bool discard_zero = ictx->config.get_val<bool>("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;
}
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);
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;
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;
{
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;
}
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;
}
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;
}
{
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;
}
{
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;
}
bool discard_zero = ictx->config.get_val<bool>("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;
}
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);
{
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;
}
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;
}
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;
}
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;
}
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;
}
bool discard_zero = ictx->config.get_val<bool>("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;
}
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;
}
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;
}
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;
}
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;
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;
}
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;
}
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;
}
} 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;
{
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;
}
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;
}
bool discard_zero = ictx->config.get_val<bool>("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;
}
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;
}
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;
#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"
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<int>(len), r);
interval_set<uint64_t> w;
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;
}
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;
}
// 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"));
// 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);
#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"
}
void flush_async_operations(librbd::ImageCtx* ictx) {
- ictx->io_work_queue->flush();
+ api::Io<>::flush(*ictx);
}
std::string m_parent_image_name;
#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"
void register_test_journal_entries() {
}
+namespace librbd {
+namespace journal {
+
class TestJournalEntries : public TestFixture {
public:
- typedef std::list<journal::Journaler *> 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;
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;
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());
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();
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');
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;
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;
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;
ASSERT_EQ(librbd::journal::EVENT_TYPE_AIO_FLUSH,
event_entry.get_event_type());
}
+
+} // namespace journal
+} // namespace librbd
#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:
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);
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) {
// 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();
}
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);
// 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();
}
// 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();
}
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();
// 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();
ASSERT_EQ(initial_tag + 1, current_tag);
ASSERT_EQ(3, current_entry);
}
+
+} // namespace journal
+} // namespace librbd
#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();
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));
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));
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")
bufferlist bl;
bl.append(std::string(((1 << m_src_ictx->order) * 2) + 1, '1'));
ASSERT_EQ(static_cast<ssize_t>(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<ssize_t>(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<ssize_t>(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<ssize_t>(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<ssize_t>(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<ssize_t>(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<ssize_t>(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<ssize_t>(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<ssize_t>(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<ssize_t>(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<ssize_t>(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"));
size_t len = (1 << m_src_ictx->order) * 2;
ASSERT_EQ(static_cast<ssize_t>(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<ssize_t>(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"));
bufferlist bl;
bl.append(std::string(100, '1'));
ASSERT_EQ(static_cast<ssize_t>(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"));
bufferlist bl;
bl.append(std::string(100, '1'));
ASSERT_EQ(static_cast<ssize_t>(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"));
ASSERT_EQ(0, snap_create(*m_src_ictx, "snap1"));
ASSERT_EQ(static_cast<ssize_t>(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"));
bufferlist bl;
bl.append(std::string(((1 << m_src_ictx->order) * 2) + 1, '1'));
ASSERT_EQ(static_cast<ssize_t>(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<ssize_t>(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"));
bufferlist bl1;
bl1.append(std::string(1000, 'X'));
ASSERT_EQ(static_cast<ssize_t>(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<ssize_t>(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"));
ASSERT_EQ(0, open_image(clone_name, &m_src_ictx));
ASSERT_EQ(static_cast<ssize_t>(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<ssize_t>(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() {
std::cout << "write: " << static_cast<char>('A' + i) << " " << off
<< "~" << len << std::endl;
ASSERT_EQ(static_cast<ssize_t>(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<uint64_t>(rand() % size),
static_cast<uint64_t>(size - len));
std::cout << "discard: " << off << "~" << len << std::endl;
ASSERT_EQ(static_cast<ssize_t>(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;
test_stress();
}
+
+} // namespace librbd
#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"
#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 <boost/scope_exit.hpp>
void register_test_migration() {
}
+namespace librbd {
+
struct TestMigration : public TestFixture {
static void SetUpTestCase() {
TestFixture::SetUpTestCase();
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
bufferlist ref_bl;
ref_bl.append(std::string(len, c));
ASSERT_EQ(static_cast<ssize_t>(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<ssize_t>(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<ssize_t>(len),
- m_ref_ictx->io_work_queue->discard(off, len, false));
+ api::Io<>::discard(*m_ref_ictx, off, len, false));
ASSERT_EQ(static_cast<ssize_t>(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) {
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));
{
test_stress2(true);
}
+
+} // namespace librbd
#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"
}
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;
}
#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 <boost/scope_exit.hpp>
void register_test_internal() {
}
+namespace librbd {
+
class TestInternal : public TestFixture {
public:
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));
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));
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,
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);
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 {
std::map<uint64_t, uint64_t> 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));
}
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);
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 {
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);
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 {
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));
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"));
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));
}
}
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));
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"));
read_bl.push_back(read_ptr);
ASSERT_EQ(static_cast<int>(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"));
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));
}
}
// 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));
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));
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));
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));
}
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));
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));
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));
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));
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);
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));
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);
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(),
ASSERT_EQ(0, create_image_pp(m_rbd, m_ioctx, m_image_name, m_image_size));
}
+
+} // namespace librbd
#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"
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);
}
char *result = (char *)malloc(len + 1);
ASSERT_NE(static_cast<char *>(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<size_t>(read));
result[len] = '\0';
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();
#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"
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));
}
}
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));
}
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));
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));
}
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));
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));
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));
}
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));
}
projects / ceph.git / commitdiff