librbd: cleanup interface between IO work queue and IO requests

This will help mock the testing of the IO work queue

(derived from commit e0834d12e91bf085a5c9503f1c69a2bee2d21edf)

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

diff --git a/src/librbd/AioImageRequest.cc b/src/librbd/AioImageRequest.cc
index d2aee487aeaa9b47008c9aa4b2b1e2d0313a18a4..7c3301b190582a086e825025a0c147db80ff2a09 100644 (file)
--- a/src/librbd/AioImageRequest.cc
+++ b/src/librbd/AioImageRequest.cc
@@ -149,6 +149,33 @@ private:
 
 } // anonymous namespace
 
+template <typename I>
+AioImageRequest<I>* AioImageRequest<I>::create_read_request(
+    I &image_ctx, AioCompletion *aio_comp, uint64_t off, size_t len,
+    char *buf, bufferlist *pbl, int op_flags) {
+  return new AioImageRead<I>(image_ctx, aio_comp, off, len, buf, pbl,
+                            op_flags);
+}
+
+template <typename I>
+AioImageRequest<I>* AioImageRequest<I>::create_write_request(
+    I &image_ctx, AioCompletion *aio_comp, uint64_t off, size_t len,
+    const char *buf, int op_flags) {
+  return new AioImageWrite<I>(image_ctx, aio_comp, off, len, buf, op_flags);
+}
+
+template <typename I>
+AioImageRequest<I>* AioImageRequest<I>::create_discard_request(
+    I &image_ctx, AioCompletion *aio_comp, uint64_t off, uint64_t len) {
+  return new AioImageDiscard<I>(image_ctx, aio_comp, off, len);
+}
+
+template <typename I>
+AioImageRequest<I>* AioImageRequest<I>::create_flush_request(
+    I &image_ctx, AioCompletion *aio_comp) {
+  return new AioImageFlush<I>(image_ctx, aio_comp);
+}
+
 template <typename I>
 void AioImageRequest<I>::aio_read(
     I *ictx, AioCompletion *c,

diff --git a/src/librbd/AioImageRequest.h b/src/librbd/AioImageRequest.h
index 3d6b3851b35b0410556414b92c59a4ef27552584..6694e5d0b0e3f1d55c5925883c9533c47387408c 100644 (file)
--- a/src/librbd/AioImageRequest.h
+++ b/src/librbd/AioImageRequest.h
@@ -26,6 +26,21 @@ public:
 
   virtual ~AioImageRequest() {}
 
+  static AioImageRequest* create_read_request(ImageCtxT &image_ctx,
+                                             AioCompletion *aio_comp,
+                                             uint64_t off, size_t len,
+                                             char *buf, bufferlist *pbl,
+                                             int op_flags);
+  static AioImageRequest* create_write_request(ImageCtxT &image_ctx,
+                                              AioCompletion *aio_comp,
+                                              uint64_t off, size_t len,
+                                              const char *buf, int op_flags);
+  static AioImageRequest* create_discard_request(ImageCtxT &image_ctx,
+                                                AioCompletion *aio_comp,
+                                                uint64_t off, uint64_t len);
+  static AioImageRequest* create_flush_request(ImageCtxT &image_ctx,
+                                              AioCompletion *aio_comp);
+
   static void aio_read(ImageCtxT *ictx, AioCompletion *c,
                        const std::vector<std::pair<uint64_t,uint64_t> > &extents,
                        char *buf, bufferlist *pbl, int op_flags);

diff --git a/src/librbd/AioImageRequestWQ.cc b/src/librbd/AioImageRequestWQ.cc
index a81d49ee90da6cddead3848ef8014fd869c93a43..d58d38772bcca11fa1c9454116122f2f4b187fbd 100644 (file)
--- a/src/librbd/AioImageRequestWQ.cc
+++ b/src/librbd/AioImageRequestWQ.cc
@@ -159,7 +159,8 @@ void AioImageRequestWQ<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 AioImageRead<>(m_image_ctx, c, off, len, buf, pbl, op_flags));
+    queue(AioImageRequest<I>::create_read_request(m_image_ctx, c, off, len,
+                                                 buf, pbl, op_flags));
   } else {
     c->start_op();
     AioImageRequest<I>::aio_read(&m_image_ctx, c, off, len, buf, pbl, op_flags);
@@ -187,7 +188,8 @@ void AioImageRequestWQ<I>::aio_write(AioCompletion *c, uint64_t off, uint64_t le
 
   RWLock::RLocker owner_locker(m_image_ctx.owner_lock);
   if (m_image_ctx.non_blocking_aio || writes_blocked()) {
-    queue(new AioImageWrite<>(m_image_ctx, c, off, len, buf, op_flags));
+    queue(AioImageRequest<I>::create_write_request(m_image_ctx, c, off, len,
+                                                  buf, op_flags));
   } else {
     c->start_op();
     AioImageRequest<I>::aio_write(&m_image_ctx, c, off, len, buf, op_flags);
@@ -214,7 +216,8 @@ void AioImageRequestWQ<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 AioImageDiscard<>(m_image_ctx, c, off, len));
+    queue(AioImageRequest<I>::create_discard_request(m_image_ctx, c, off,
+                                                    len));
   } else {
     c->start_op();
     AioImageRequest<I>::aio_discard(&m_image_ctx, c, off, len);
@@ -239,7 +242,7 @@ void AioImageRequestWQ<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 AioImageFlush<>(m_image_ctx, c));
+    queue(AioImageRequest<I>::create_flush_request(m_image_ctx, c));
   } else {
     AioImageRequest<I>::aio_flush(&m_image_ctx, c);
     finish_in_flight_io();