librbd: refresh image IO dispatch layer

This layer will handle refreshing the image if required upon incoming
IO requests.

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

diff --git a/src/librbd/CMakeLists.txt b/src/librbd/CMakeLists.txt
index ef9e1baf7310bbbbc28a5805526f286927963774..c7fe73f02ab3eaf622fa3944a3888771de746836 100644 (file)
--- a/src/librbd/CMakeLists.txt
+++ b/src/librbd/CMakeLists.txt
@@ -84,6 +84,7 @@ set(librbd_internal_srcs
   io/ObjectRequest.cc
   io/QosImageDispatch.cc
   io/ReadResult.cc
+  io/RefreshImageDispatch.cc
   io/SimpleSchedulerObjectDispatch.cc
   io/Utils.cc
   journal/CreateRequest.cc

diff --git a/src/librbd/io/ImageDispatcher.cc b/src/librbd/io/ImageDispatcher.cc
index f4fdca25a8a96e9979362ae1f99b3f6bec6456ba..d48016d8c876a59d35060383c3091439463f9651 100644 (file)
--- a/src/librbd/io/ImageDispatcher.cc
+++ b/src/librbd/io/ImageDispatcher.cc
@@ -12,6 +12,7 @@
 #include "librbd/io/ImageDispatchInterface.h"
 #include "librbd/io/ImageDispatchSpec.h"
 #include "librbd/io/QosImageDispatch.h"
+#include "librbd/io/RefreshImageDispatch.h"
 #include <boost/variant.hpp>
 
 #define dout_subsys ceph_subsys_rbd
@@ -107,6 +108,9 @@ ImageDispatcher<I>::ImageDispatcher(I* image_ctx)
 
   m_qos_image_dispatch = new QosImageDispatch<I>(image_ctx);
   this->register_dispatch(m_qos_image_dispatch);
+
+  auto refresh_image_dispatch = new RefreshImageDispatch(image_ctx);
+  this->register_dispatch(refresh_image_dispatch);
 }
 
 template <typename I>

diff --git a/src/librbd/io/RefreshImageDispatch.cc b/src/librbd/io/RefreshImageDispatch.cc
new file mode 100644 (file)
index 0000000..4632660
--- /dev/null
+++ b/src/librbd/io/RefreshImageDispatch.cc
@@ -0,0 +1,155 @@
+// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
+// vim: ts=8 sw=2 smarttab
+
+#include "librbd/io/RefreshImageDispatch.h"
+#include "common/dout.h"
+#include "librbd/ImageCtx.h"
+#include "librbd/ImageState.h"
+#include <map>
+
+#define dout_subsys ceph_subsys_rbd
+#undef dout_prefix
+#define dout_prefix *_dout << "librbd::io::RefreshImageDispatch: " << this \
+                           << " " << __func__ << ": "
+
+namespace librbd {
+namespace io {
+
+template <typename I>
+RefreshImageDispatch<I>::RefreshImageDispatch(I* image_ctx)
+  : m_image_ctx(image_ctx) {
+  auto cct = m_image_ctx->cct;
+  ldout(cct, 5) << "ictx=" << image_ctx << dendl;
+}
+
+template <typename I>
+void RefreshImageDispatch<I>::shut_down(Context* on_finish) {
+  on_finish->complete(0);
+}
+
+template <typename I>
+bool RefreshImageDispatch<I>::read(
+    AioCompletion* aio_comp, Extents &&image_extents, ReadResult &&read_result,
+    int op_flags, const ZTracer::Trace &parent_trace, uint64_t tid,
+    std::atomic<uint32_t>* image_dispatch_flags,
+    DispatchResult* dispatch_result, Context* on_dispatched) {
+  auto cct = m_image_ctx->cct;
+  ldout(cct, 20) << "tid=" << tid << ", image_extents=" << image_extents
+                 << dendl;
+
+  if (needs_refresh(dispatch_result, on_dispatched)) {
+    return true;
+  }
+
+  return false;
+}
+
+template <typename I>
+bool RefreshImageDispatch<I>::write(
+    AioCompletion* aio_comp, Extents &&image_extents, bufferlist &&bl,
+    int op_flags, const ZTracer::Trace &parent_trace, uint64_t tid,
+    std::atomic<uint32_t>* image_dispatch_flags,
+    DispatchResult* dispatch_result, Context* on_dispatched) {
+  auto cct = m_image_ctx->cct;
+  ldout(cct, 20) << "tid=" << tid << ", image_extents=" << image_extents
+                 << dendl;
+
+  if (needs_refresh(dispatch_result, on_dispatched)) {
+    return true;
+  }
+
+  return false;
+}
+
+template <typename I>
+bool RefreshImageDispatch<I>::discard(
+    AioCompletion* aio_comp, Extents &&image_extents,
+    uint32_t discard_granularity_bytes, const ZTracer::Trace &parent_trace,
+    uint64_t tid, std::atomic<uint32_t>* image_dispatch_flags,
+    DispatchResult* dispatch_result, Context* on_dispatched) {
+  auto cct = m_image_ctx->cct;
+  ldout(cct, 20) << "tid=" << tid << ", image_extents=" << image_extents
+                 << dendl;
+
+  if (needs_refresh(dispatch_result, on_dispatched)) {
+    return true;
+  }
+
+  return false;
+}
+
+template <typename I>
+bool RefreshImageDispatch<I>::write_same(
+    AioCompletion* aio_comp, Extents &&image_extents, bufferlist &&bl,
+    int op_flags, const ZTracer::Trace &parent_trace, uint64_t tid,
+    std::atomic<uint32_t>* image_dispatch_flags,
+    DispatchResult* dispatch_result, Context* on_dispatched) {
+  auto cct = m_image_ctx->cct;
+  ldout(cct, 20) << "tid=" << tid << ", image_extents=" << image_extents
+                 << dendl;
+
+  if (needs_refresh(dispatch_result, on_dispatched)) {
+    return true;
+  }
+
+  return false;
+}
+
+template <typename I>
+bool RefreshImageDispatch<I>::compare_and_write(
+    AioCompletion* aio_comp, Extents &&image_extents, bufferlist &&cmp_bl,
+    bufferlist &&bl, uint64_t *mismatch_offset, int op_flags,
+    const ZTracer::Trace &parent_trace, uint64_t tid,
+    std::atomic<uint32_t>* image_dispatch_flags,
+    DispatchResult* dispatch_result, Context* on_dispatched) {
+  auto cct = m_image_ctx->cct;
+  ldout(cct, 20) << "tid=" << tid << ", image_extents=" << image_extents
+                 << dendl;
+
+  if (needs_refresh(dispatch_result, on_dispatched)) {
+    return true;
+  }
+
+  return false;
+}
+
+template <typename I>
+bool RefreshImageDispatch<I>::flush(
+    AioCompletion* aio_comp, FlushSource flush_source,
+    const ZTracer::Trace &parent_trace, uint64_t tid,
+    std::atomic<uint32_t>* image_dispatch_flags,
+    DispatchResult* dispatch_result, Context* on_dispatched) {
+  auto cct = m_image_ctx->cct;
+  ldout(cct, 20) << "tid=" << tid << dendl;
+
+  if (flush_source != FLUSH_SOURCE_USER) {
+    return false;
+  }
+
+  if (needs_refresh(dispatch_result, on_dispatched)) {
+    return true;
+  }
+
+  return false;
+}
+
+template <typename I>
+bool RefreshImageDispatch<I>::needs_refresh(
+    DispatchResult* dispatch_result, Context* on_dispatched) {
+  auto cct = m_image_ctx->cct;
+
+  if (m_image_ctx->state->is_refresh_required()) {
+    ldout(cct, 15) << "on_dispatched=" << on_dispatched << dendl;
+
+    *dispatch_result = DISPATCH_RESULT_CONTINUE;
+    m_image_ctx->state->refresh(on_dispatched);
+    return true;
+  }
+
+  return false;
+}
+
+} // namespace io
+} // namespace librbd
+
+template class librbd::io::RefreshImageDispatch<librbd::ImageCtx>;

diff --git a/src/librbd/io/RefreshImageDispatch.h b/src/librbd/io/RefreshImageDispatch.h
new file mode 100644 (file)
index 0000000..154ff64
--- /dev/null
+++ b/src/librbd/io/RefreshImageDispatch.h
@@ -0,0 +1,84 @@
+// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
+// vim: ts=8 sw=2 smarttab
+
+#ifndef CEPH_LIBRBD_IO_REFRESH_IMAGE_DISPATCH_H
+#define CEPH_LIBRBD_IO_REFRESH_IMAGE_DISPATCH_H
+
+#include "librbd/io/ImageDispatchInterface.h"
+#include "include/int_types.h"
+#include "include/buffer.h"
+#include "common/zipkin_trace.h"
+#include "common/Throttle.h"
+#include "librbd/io/ReadResult.h"
+#include "librbd/io/Types.h"
+
+struct Context;
+
+namespace librbd {
+
+struct ImageCtx;
+
+namespace io {
+
+struct AioCompletion;
+
+template <typename ImageCtxT>
+class RefreshImageDispatch : public ImageDispatchInterface {
+public:
+  RefreshImageDispatch(ImageCtxT* image_ctx);
+
+  ImageDispatchLayer get_dispatch_layer() const override {
+    return IMAGE_DISPATCH_LAYER_REFRESH;
+  }
+
+  void shut_down(Context* on_finish) override;
+
+  bool read(
+      AioCompletion* aio_comp, Extents &&image_extents,
+      ReadResult &&read_result, int op_flags,
+      const ZTracer::Trace &parent_trace, uint64_t tid,
+      std::atomic<uint32_t>* image_dispatch_flags,
+      DispatchResult* dispatch_result, Context* on_dispatched) override;
+  bool write(
+      AioCompletion* aio_comp, Extents &&image_extents, bufferlist &&bl,
+      int op_flags, const ZTracer::Trace &parent_trace, uint64_t tid,
+      std::atomic<uint32_t>* image_dispatch_flags,
+      DispatchResult* dispatch_result, Context* on_dispatched) override;
+  bool discard(
+      AioCompletion* aio_comp, Extents &&image_extents,
+      uint32_t discard_granularity_bytes,
+      const ZTracer::Trace &parent_trace, uint64_t tid,
+      std::atomic<uint32_t>* image_dispatch_flags,
+      DispatchResult* dispatch_result, Context* on_dispatched) override;
+  bool write_same(
+      AioCompletion* aio_comp, Extents &&image_extents, bufferlist &&bl,
+      int op_flags, const ZTracer::Trace &parent_trace, uint64_t tid,
+      std::atomic<uint32_t>* image_dispatch_flags,
+      DispatchResult* dispatch_result, Context* on_dispatched) override;
+  bool compare_and_write(
+      AioCompletion* aio_comp, Extents &&image_extents, bufferlist &&cmp_bl,
+      bufferlist &&bl, uint64_t *mismatch_offset, int op_flags,
+      const ZTracer::Trace &parent_trace, uint64_t tid,
+      std::atomic<uint32_t>* image_dispatch_flags,
+      DispatchResult* dispatch_result, Context* on_dispatched) override;
+  bool flush(
+      AioCompletion* aio_comp, FlushSource flush_source,
+      const ZTracer::Trace &parent_trace, uint64_t tid,
+      std::atomic<uint32_t>* image_dispatch_flags,
+      DispatchResult* dispatch_result, Context* on_dispatched) override;
+
+  void handle_finished(int r, uint64_t tid) override {}
+
+private:
+  ImageCtxT* m_image_ctx;
+
+  bool needs_refresh(DispatchResult* dispatch_result, Context* on_dispatched);
+
+};
+
+} // namespace io
+} // namespace librbd
+
+extern template class librbd::io::RefreshImageDispatch<librbd::ImageCtx>;
+
+#endif // CEPH_LIBRBD_IO_REFRESH_IMAGE_DISPATCH_H