librbd: cleanup interface between IO work queue and IO requests

This will help mock the testing of the IO work queue

Signed-off-by: Jason Dillaman <dillaman@redhat.com>

diff --git a/src/librbd/io/ImageRequest.cc b/src/librbd/io/ImageRequest.cc
index 80c7208a1440ab6241213b31b26a38456565d951..8afd6556a32c8bba0c3251b931a00a66a4c2fc6c 100644 (file)
--- a/src/librbd/io/ImageRequest.cc
+++ b/src/librbd/io/ImageRequest.cc
@@ -108,6 +108,48 @@ private:
 
 } // anonymous namespace
 
+template <typename I>
+ImageRequest<I>* ImageRequest<I>::create_read_request(
+    I &image_ctx, AioCompletion *aio_comp, Extents &&image_extents,
+    ReadResult &&read_result, int op_flags,
+    const ZTracer::Trace &parent_trace) {
+  return new ImageReadRequest<I>(image_ctx, aio_comp,
+                                 std::move(image_extents),
+                                 std::move(read_result), op_flags,
+                                 parent_trace);
+}
+
+template <typename I>
+ImageRequest<I>* ImageRequest<I>::create_write_request(
+    I &image_ctx, AioCompletion *aio_comp, Extents &&image_extents,
+    bufferlist &&bl, int op_flags, const ZTracer::Trace &parent_trace) {
+  return new ImageWriteRequest<I>(image_ctx, aio_comp, std::move(image_extents),
+                                  std::move(bl), op_flags, parent_trace);
+}
+
+template <typename I>
+ImageRequest<I>* ImageRequest<I>::create_discard_request(
+    I &image_ctx, AioCompletion *aio_comp, uint64_t off, uint64_t len,
+    bool skip_partial_discard, const ZTracer::Trace &parent_trace) {
+  return new ImageDiscardRequest<I>(image_ctx, aio_comp, off, len,
+                                    skip_partial_discard, parent_trace);
+}
+
+template <typename I>
+ImageRequest<I>* ImageRequest<I>::create_flush_request(
+    I &image_ctx, AioCompletion *aio_comp,
+    const ZTracer::Trace &parent_trace) {
+  return new ImageFlushRequest<I>(image_ctx, aio_comp, parent_trace);
+}
+
+template <typename I>
+ImageRequest<I>* ImageRequest<I>::create_writesame_request(
+    I &image_ctx, AioCompletion *aio_comp, uint64_t off, uint64_t len,
+    bufferlist &&bl, int op_flags, const ZTracer::Trace &parent_trace) {
+  return new ImageWriteSameRequest<I>(image_ctx, aio_comp, off, len,
+                                      std::move(bl), op_flags, parent_trace);
+}
+
 template <typename I>
 void ImageRequest<I>::aio_read(I *ictx, AioCompletion *c,
                                Extents &&image_extents,

diff --git a/src/librbd/io/ImageRequest.h b/src/librbd/io/ImageRequest.h
index 21b88b098cf5736ee2907007357139da61d835c0..de19f490c6f282abe17185d2d6d884d43a51b16e 100644 (file)
--- a/src/librbd/io/ImageRequest.h
+++ b/src/librbd/io/ImageRequest.h
@@ -33,6 +33,31 @@ public:
     m_trace.event("finish");
   }
 
+  static ImageRequest* create_read_request(ImageCtxT &image_ctx,
+                                           AioCompletion *aio_comp,
+                                           Extents &&image_extents,
+                                           ReadResult &&read_result,
+                                           int op_flags,
+                                           const ZTracer::Trace &parent_trace);
+  static ImageRequest* create_write_request(ImageCtxT &image_ctx,
+                                            AioCompletion *aio_comp,
+                                            Extents &&image_extents,
+                                            bufferlist &&bl, int op_flags,
+                                            const ZTracer::Trace &parent_trace);
+  static ImageRequest* create_discard_request(ImageCtxT &image_ctx,
+                                              AioCompletion *aio_comp,
+                                              uint64_t off, uint64_t len,
+                                              bool skip_partial_discard,
+                                              const ZTracer::Trace &parent_trace);
+  static ImageRequest* create_flush_request(ImageCtxT &image_ctx,
+                                            AioCompletion *aio_comp,
+                                            const ZTracer::Trace &parent_trace);
+  static ImageRequest* create_writesame_request(ImageCtxT &image_ctx,
+                                                AioCompletion *aio_comp,
+                                                uint64_t off, uint64_t len,
+                                                bufferlist &&bl, int op_flags,
+                                                const ZTracer::Trace &parent_trace);
+
   static void aio_read(ImageCtxT *ictx, AioCompletion *c,
                        Extents &&image_extents, ReadResult &&read_result,
                        int op_flags, const ZTracer::Trace &parent_trace);

diff --git a/src/librbd/io/ImageRequestWQ.cc b/src/librbd/io/ImageRequestWQ.cc
index 593301c5abcf7f8037a51a14d1b9af95164497df..547c773e578a555c5499a845d88a6fb6a2dea844 100644 (file)
--- a/src/librbd/io/ImageRequestWQ.cc
+++ b/src/librbd/io/ImageRequestWQ.cc
@@ -192,8 +192,9 @@ void ImageRequestWQ<I>::aio_read(AioCompletion *c, uint64_t off, uint64_t len,
   RWLock::RLocker owner_locker(m_image_ctx.owner_lock);
   if (m_image_ctx.non_blocking_aio || writes_blocked() || !writes_empty() ||
       require_lock_on_read()) {
-    queue(new ImageReadRequest<I>(m_image_ctx, c, {{off, len}},
-                                 std::move(read_result), op_flags, trace));
+    queue(ImageRequest<I>::create_read_request(
+            m_image_ctx, c, {{off, len}}, std::move(read_result), op_flags,
+            trace));
   } else {
     c->start_op();
     ImageRequest<I>::aio_read(&m_image_ctx, c, {{off, len}},
@@ -229,8 +230,8 @@ void ImageRequestWQ<I>::aio_write(AioCompletion *c, uint64_t off, uint64_t len,
 
   RWLock::RLocker owner_locker(m_image_ctx.owner_lock);
   if (m_image_ctx.non_blocking_aio || writes_blocked()) {
-    queue(new ImageWriteRequest<I>(m_image_ctx, c, {{off, len}},
-                                  std::move(bl), op_flags, trace));
+    queue(ImageRequest<I>::create_write_request(
+            m_image_ctx, c, {{off, len}}, std::move(bl), op_flags, trace));
   } else {
     c->start_op();
     ImageRequest<I>::aio_write(&m_image_ctx, c, {{off, len}},
@@ -266,8 +267,8 @@ void ImageRequestWQ<I>::aio_discard(AioCompletion *c, uint64_t off,
 
   RWLock::RLocker owner_locker(m_image_ctx.owner_lock);
   if (m_image_ctx.non_blocking_aio || writes_blocked()) {
-    queue(new ImageDiscardRequest<I>(m_image_ctx, c, off, len,
-                                    skip_partial_discard, trace));
+    queue(ImageRequest<I>::create_discard_request(
+            m_image_ctx, c, off, len, skip_partial_discard, trace));
   } else {
     c->start_op();
     ImageRequest<I>::aio_discard(&m_image_ctx, c, off, len,
@@ -300,7 +301,7 @@ void ImageRequestWQ<I>::aio_flush(AioCompletion *c, bool native_async) {
 
   RWLock::RLocker owner_locker(m_image_ctx.owner_lock);
   if (m_image_ctx.non_blocking_aio || writes_blocked() || !writes_empty()) {
-    queue(new ImageFlushRequest<I>(m_image_ctx, c, trace));
+    queue(ImageRequest<I>::create_flush_request(m_image_ctx, c, trace));
   } else {
     ImageRequest<I>::aio_flush(&m_image_ctx, c, trace);
     finish_in_flight_io();
@@ -335,8 +336,8 @@ void ImageRequestWQ<I>::aio_writesame(AioCompletion *c, uint64_t off,
 
   RWLock::RLocker owner_locker(m_image_ctx.owner_lock);
   if (m_image_ctx.non_blocking_aio || writes_blocked()) {
-    queue(new ImageWriteSameRequest<I>(m_image_ctx, c, off, len, std::move(bl),
-                                      op_flags, trace));
+    queue(ImageRequest<I>::create_writesame_request(
+            m_image_ctx, c, off, len, std::move(bl), op_flags, trace));
   } else {
     c->start_op();
     ImageRequest<I>::aio_writesame(&m_image_ctx, c, off, len, std::move(bl),