librbd: simplify AioImageRequestWQ function signatures

The ImageCtx is known so there is no need to pass it with each
function call.

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

diff --git a/src/librbd/AioImageRequestWQ.cc b/src/librbd/AioImageRequestWQ.cc
index 82cdb0202cb52d77e7b45c44e90b0b06dee72f2b..c5952bad207b6da981ed22eef10fa0c83dd81a23 100644 (file)
--- a/src/librbd/AioImageRequestWQ.cc
+++ b/src/librbd/AioImageRequestWQ.cc
@@ -5,48 +5,47 @@
 #include "librbd/AioCompletion.h"
 #include "librbd/AioImageRequest.h"
 #include "librbd/ImageCtx.h"
+#include "librbd/ImageWatcher.h"
 #include "librbd/internal.h"
 
 namespace librbd {
 
-void AioImageRequestWQ::aio_read(ImageCtx *ictx, uint64_t off, size_t len,
-                                 char *buf, bufferlist *pbl, AioCompletion *c,
-                                 int op_flags) {
-  c->init_time(ictx, librbd::AIO_TYPE_READ);
-  if (ictx->non_blocking_aio) {
-    queue(new AioImageRead(*ictx, c, off, len, buf, pbl, op_flags));
+void AioImageRequestWQ::aio_read(AioCompletion *c, uint64_t off, size_t len,
+                                 char *buf, bufferlist *pbl, int op_flags) {
+  c->init_time(&m_image_ctx, librbd::AIO_TYPE_READ);
+  if (m_image_ctx.non_blocking_aio) {
+    queue(new AioImageRead(m_image_ctx, c, off, len, buf, pbl, op_flags));
   } else {
-    AioImageRequest::read(ictx, c, off, len, buf, pbl, op_flags);
+    AioImageRequest::read(&m_image_ctx, c, off, len, buf, pbl, op_flags);
   }
 }
 
-void AioImageRequestWQ::aio_write(ImageCtx *ictx, uint64_t off, size_t len,
-                                  const char *buf, AioCompletion *c,
-                                  int op_flags) {
-  c->init_time(ictx, librbd::AIO_TYPE_WRITE);
-  if (ictx->non_blocking_aio) {
-    queue(new AioImageWrite(*ictx, c, off, len, buf, op_flags));
+void AioImageRequestWQ::aio_write(AioCompletion *c, uint64_t off, size_t len,
+                                  const char *buf, int op_flags) {
+  c->init_time(&m_image_ctx, librbd::AIO_TYPE_WRITE);
+  if (m_image_ctx.non_blocking_aio) {
+    queue(new AioImageWrite(m_image_ctx, c, off, len, buf, op_flags));
   } else {
-    AioImageRequest::write(ictx, c, off, len, buf, op_flags);
+    AioImageRequest::write(&m_image_ctx, c, off, len, buf, op_flags);
   }
 }
 
-void AioImageRequestWQ::aio_discard(ImageCtx *ictx, uint64_t off, uint64_t len,
-                                    AioCompletion *c) {
-  c->init_time(ictx, librbd::AIO_TYPE_DISCARD);
-  if (ictx->non_blocking_aio) {
-    queue(new AioImageDiscard(*ictx, c, off, len));
+void AioImageRequestWQ::aio_discard(AioCompletion *c, uint64_t off,
+                                    uint64_t len) {
+  c->init_time(&m_image_ctx, librbd::AIO_TYPE_DISCARD);
+  if (m_image_ctx.non_blocking_aio) {
+    queue(new AioImageDiscard(m_image_ctx, c, off, len));
   } else {
-    AioImageRequest::discard(ictx, c, off, len);
+    AioImageRequest::discard(&m_image_ctx, c, off, len);
   }
 }
 
-void AioImageRequestWQ::aio_flush(ImageCtx *ictx, AioCompletion *c) {
-  c->init_time(ictx, librbd::AIO_TYPE_FLUSH);
-  if (ictx->non_blocking_aio) {
-    queue(new AioImageFlush(*ictx, c));
+void AioImageRequestWQ::aio_flush(AioCompletion *c) {
+  c->init_time(&m_image_ctx, librbd::AIO_TYPE_FLUSH);
+  if (m_image_ctx.non_blocking_aio) {
+    queue(new AioImageFlush(m_image_ctx, c));
   } else {
-    AioImageRequest::flush(ictx, c);
+    AioImageRequest::flush(&m_image_ctx, c);
   }
 }
 

diff --git a/src/librbd/AioImageRequestWQ.h b/src/librbd/AioImageRequestWQ.h
index f5c0b8e647da60ac8de17ee6ba1fd61e961bbf6f..82a35ff0531524ef102fd0b3a80edbe52c39d8b7 100644 (file)
--- a/src/librbd/AioImageRequestWQ.h
+++ b/src/librbd/AioImageRequestWQ.h
@@ -15,19 +15,19 @@ class ImageCtx;
 
 class AioImageRequestWQ : protected ThreadPool::PointerWQ<AioImageRequest> {
 public:
-  AioImageRequestWQ(const string &name, time_t ti, ThreadPool *tp)
+  AioImageRequestWQ(ImageCtx *image_ctx, const string &name, time_t ti,
+                    ThreadPool *tp)
     : ThreadPool::PointerWQ<AioImageRequest>(name, ti, 0, tp),
-      m_lock("AioImageRequestWQ::m_lock"), m_writes_suspended(false),
-      m_in_progress_writes(0), m_queued_writes(0) {
+      m_image_ctx(*image_ctx), m_lock("AioImageRequestWQ::m_lock"),
+      m_writes_suspended(false), m_in_progress_writes(0), m_queued_writes(0) {
   }
 
-  void aio_read(ImageCtx *ictx, uint64_t off, size_t len, char *buf,
-                bufferlist *pbl, AioCompletion *c, int op_flags);
-  void aio_write(ImageCtx *ictx, uint64_t off, size_t len, const char *buf,
-                 AioCompletion *c, int op_flags);
-  void aio_discard(ImageCtx *ictx, uint64_t off, uint64_t len,
-                   AioCompletion *c);
-  void aio_flush(ImageCtx *ictx, AioCompletion *c);
+  void aio_read(AioCompletion *c, uint64_t off, size_t len, char *buf,
+                bufferlist *pbl, int op_flags);
+  void aio_write(AioCompletion *c, uint64_t off, size_t len, const char *buf,
+                 int op_flags);
+  void aio_discard(AioCompletion *c, uint64_t off, uint64_t len);
+  void aio_flush(AioCompletion *c);
 
   using ThreadPool::PointerWQ<AioImageRequest>::drain;
 
@@ -55,6 +55,7 @@ protected:
   virtual void *_void_dequeue();
   virtual void process(AioImageRequest *req);
 private:
+  ImageCtx &m_image_ctx;
   mutable Mutex m_lock;
   Cond m_cond;
   bool m_writes_suspended;

diff --git a/src/librbd/ImageCtx.cc b/src/librbd/ImageCtx.cc
index ac2e3300125b5d575f641c1f8245977180260c52..f371658d757223cade00962487a90cfc6d2de20a 100644 (file)
--- a/src/librbd/ImageCtx.cc
+++ b/src/librbd/ImageCtx.cc
@@ -101,7 +101,7 @@ public:
     ThreadPoolSingleton *thread_pool_singleton;
     cct->lookup_or_create_singleton_object<ThreadPoolSingleton>(
       thread_pool_singleton, "librbd::thread_pool");
-    aio_work_queue = new AioImageRequestWQ("librbd::aio_work_queue",
+    aio_work_queue = new AioImageRequestWQ(this, "librbd::aio_work_queue",
                                            cct->_conf->rbd_op_thread_timeout,
                                            thread_pool_singleton);
     op_work_queue = new ContextWQ("librbd::op_work_queue",

diff --git a/src/librbd/librbd.cc b/src/librbd/librbd.cc
index b7345f9c7547efd429f245121cd9be8768bafa0a..fe387c63044dd049a31c7903aeca2a3d14c14db2 100644 (file)
--- a/src/librbd/librbd.cc
+++ b/src/librbd/librbd.cc
@@ -897,8 +897,8 @@ namespace librbd {
       tracepoint(librbd, aio_write_exit, -EINVAL);
       return -EINVAL;
     }
-    ictx->aio_work_queue->aio_write(ictx, off, len, bl.c_str(),
-                                    get_aio_completion(c), 0);
+    ictx->aio_work_queue->aio_write(get_aio_completion(c), off, len, bl.c_str(),
+                                    0);
     tracepoint(librbd, aio_write_exit, 0);
     return 0;
   }
@@ -913,8 +913,8 @@ namespace librbd {
       tracepoint(librbd, aio_write_exit, -EINVAL);
       return -EINVAL;
     }
-    ictx->aio_work_queue->aio_write(ictx, off, len, bl.c_str(),
-                                    get_aio_completion(c), op_flags);
+    ictx->aio_work_queue->aio_write(get_aio_completion(c), off, len, bl.c_str(),
+                                    op_flags);
     tracepoint(librbd, aio_write_exit, 0);
     return 0;
   }
@@ -923,7 +923,7 @@ 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->aio_work_queue->aio_discard(ictx, off, len, get_aio_completion(c));
+    ictx->aio_work_queue->aio_discard(get_aio_completion(c), off, len);
     tracepoint(librbd, aio_discard_exit, 0);
     return 0;
   }
@@ -935,8 +935,8 @@ namespace librbd {
     tracepoint(librbd, aio_read_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, off, len, bl.c_str(), c->pc);
     ldout(ictx->cct, 10) << "Image::aio_read() buf=" << (void *)bl.c_str() << "~"
                         << (void *)(bl.c_str() + len - 1) << dendl;
-    ictx->aio_work_queue->aio_read(ictx, off, len, NULL, &bl,
-                                   get_aio_completion(c), 0);
+    ictx->aio_work_queue->aio_read(get_aio_completion(c), off, len, NULL, &bl,
+                                   0);
     tracepoint(librbd, aio_read_exit, 0);
     return 0;
   }
@@ -949,8 +949,8 @@ namespace librbd {
                ictx->read_only, off, len, bl.c_str(), c->pc, op_flags);
     ldout(ictx->cct, 10) << "Image::aio_read() buf=" << (void *)bl.c_str() << "~"
                         << (void *)(bl.c_str() + len - 1) << dendl;
-    ictx->aio_work_queue->aio_read(ictx, off, len, NULL, &bl,
-                                   get_aio_completion(c), op_flags);
+    ictx->aio_work_queue->aio_read(get_aio_completion(c), off, len, NULL, &bl,
+                                   op_flags);
     tracepoint(librbd, aio_read_exit, 0);
     return 0;
   }
@@ -968,7 +968,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->aio_work_queue->aio_flush(ictx, get_aio_completion(c));
+    ictx->aio_work_queue->aio_flush(get_aio_completion(c));
     tracepoint(librbd, aio_flush_exit, 0);
     return 0;
   }
@@ -2029,8 +2029,7 @@ extern "C" int rbd_aio_write(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_write_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, off, len, buf, comp->pc);
-  ictx->aio_work_queue->aio_write(ictx, off, len, buf,
-                                  get_aio_completion(comp), 0);
+  ictx->aio_work_queue->aio_write(get_aio_completion(comp), off, len, buf, 0);
   tracepoint(librbd, aio_write_exit, 0);
   return 0;
 }
@@ -2042,7 +2041,7 @@ extern "C" int rbd_aio_write2(rbd_image_t image, uint64_t off, size_t len,
   librbd::RBD::AioCompletion *comp = (librbd::RBD::AioCompletion *)c;
   tracepoint(librbd, aio_write2_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(),
              ictx->read_only, off, len, buf, comp->pc, op_flags);
-  ictx->aio_work_queue->aio_write(ictx, off, len, buf, get_aio_completion(comp),
+  ictx->aio_work_queue->aio_write(get_aio_completion(comp), off, len, buf,
                                   op_flags);
   tracepoint(librbd, aio_write_exit, 0);
   return 0;
@@ -2055,7 +2054,7 @@ 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->aio_work_queue->aio_discard(ictx, off, len, get_aio_completion(comp));
+  ictx->aio_work_queue->aio_discard(get_aio_completion(comp), off, len);
   tracepoint(librbd, aio_discard_exit, 0);
   return 0;
 }
@@ -2066,8 +2065,8 @@ 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->aio_work_queue->aio_read(ictx, off, len, buf, NULL,
-                                 get_aio_completion(comp), 0);
+  ictx->aio_work_queue->aio_read(get_aio_completion(comp), off, len, buf, NULL,
+                                 0);
   tracepoint(librbd, aio_read_exit, 0);
   return 0;
 }
@@ -2079,8 +2078,8 @@ 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->aio_work_queue->aio_read(ictx, off, len, buf, NULL,
-                                 get_aio_completion(comp), op_flags);
+  ictx->aio_work_queue->aio_read(get_aio_completion(comp), off, len, buf, NULL,
+                                 op_flags);
   tracepoint(librbd, aio_read_exit, 0);
   return 0;
 }
@@ -2099,7 +2098,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->aio_work_queue->aio_flush(ictx, get_aio_completion(comp));
+  ictx->aio_work_queue->aio_flush(get_aio_completion(comp));
   tracepoint(librbd, aio_flush_exit, 0);
   return 0;
 }