librbd/cache/pwl: Fix IO completion

- Fix deep copy tests and discard I/O completion

- Change read extents to a pointer so that data
persists when multiple extents are pushed into the
vector of bufferlists

- Cleanup tests

Signed-off-by: Mahati Chamarthy <mahati.chamarthy@intel.com>
(cherry picked from commit eeb0b405044bfaade49da0cc635bc05fb0286c0f)

diff --git a/src/librbd/CMakeLists.txt b/src/librbd/CMakeLists.txt
index 512cef995b8dc917829a1713a32f87bd90dc97e0..9e9365d1f95e187c8af2f427e009c13678a28043 100644 (file)
--- a/src/librbd/CMakeLists.txt
+++ b/src/librbd/CMakeLists.txt
@@ -280,6 +280,7 @@ if(WITH_RBD_RWL OR WITH_RBD_SSD_CACHE)
       set(rbd_plugin_pwl_srcs
         ${rbd_plugin_pwl_srcs}
         cache/pwl/ssd/LogEntry.cc
+        cache/pwl/ssd/LogOperation.cc
         cache/pwl/ssd/ReadRequest.cc
         cache/pwl/ssd/Request.cc
         cache/pwl/ssd/WriteLog.cc)

diff --git a/src/librbd/cache/pwl/AbstractWriteLog.cc b/src/librbd/cache/pwl/AbstractWriteLog.cc
index 0c3b7cb1891cd4abfffa791bbe9c7c9b466b26c4..640fead2e1891c19562fd4fa34a407612a97e0c7 100644 (file)
--- a/src/librbd/cache/pwl/AbstractWriteLog.cc
+++ b/src/librbd/cache/pwl/AbstractWriteLog.cc
@@ -668,7 +668,6 @@ template <typename I>
 void AbstractWriteLog<I>::read(Extents&& image_extents,
                                      ceph::bufferlist* bl,
                                      int fadvise_flags, Context *on_finish) {
-  // TODO: handle writesame and discard case in later PRs
   CephContext *cct = m_image_ctx.cct;
   utime_t now = ceph_clock_now();
 
@@ -737,7 +736,7 @@ void AbstractWriteLog<I>::read(Extents&& image_extents,
         Extent miss_extent(miss_extent_start, miss_extent_length);
         read_ctx->miss_extents.push_back(miss_extent);
         /* Add miss range to read extents */
-        ImageExtentBuf miss_extent_buf(miss_extent);
+        auto miss_extent_buf = std::make_shared<ImageExtentBuf>(miss_extent);
         read_ctx->read_extents.push_back(miss_extent_buf);
         extent_offset += miss_extent_length;
       }
@@ -756,6 +755,7 @@ void AbstractWriteLog<I>::read(Extents&& image_extents,
       if (0 == map_entry.log_entry->write_bytes() &&
           0 < map_entry.log_entry->bytes_dirty()) {
         /* discard log entry */
+        ldout(cct, 20) << "discard log entry" << dendl;
         auto discard_entry = map_entry.log_entry;
         ldout(cct, 20) << "read hit on discard entry: log_entry="
                        << *discard_entry
@@ -764,9 +764,11 @@ void AbstractWriteLog<I>::read(Extents&& image_extents,
         bufferlist zero_bl;
         zero_bl.append_zero(entry_hit_length);
         /* Add hit extent to read extents */
-        ImageExtentBuf hit_extent_buf(hit_extent, zero_bl);
+        auto hit_extent_buf = std::make_shared<ImageExtentBuf>(
+            hit_extent, zero_bl);
         read_ctx->read_extents.push_back(hit_extent_buf);
       } else {
+        ldout(cct, 20) << "write or writesame log entry" << dendl;
         /* write and writesame log entry */
         /* Offset of the map entry into the log entry's buffer */
         uint64_t map_entry_buffer_offset = entry_image_extent.first -
@@ -790,7 +792,7 @@ void AbstractWriteLog<I>::read(Extents&& image_extents,
       Extent miss_extent(miss_extent_start, miss_extent_length);
       read_ctx->miss_extents.push_back(miss_extent);
       /* Add miss range to read extents */
-      ImageExtentBuf miss_extent_buf(miss_extent);
+      auto miss_extent_buf = std::make_shared<ImageExtentBuf>(miss_extent);
       read_ctx->read_extents.push_back(miss_extent_buf);
       extent_offset += miss_extent_length;
     }
@@ -878,7 +880,8 @@ void AbstractWriteLog<I>::flush(io::FlushSource flush_source, Context *on_finish
   CephContext *cct = m_image_ctx.cct;
   ldout(cct, 20) << "on_finish=" << on_finish << " flush_source=" << flush_source << dendl;
 
-  if (io::FLUSH_SOURCE_SHUTDOWN == flush_source || io::FLUSH_SOURCE_INTERNAL == flush_source) {
+  if (io::FLUSH_SOURCE_SHUTDOWN == flush_source || io::FLUSH_SOURCE_INTERNAL == flush_source ||
+      io::FLUSH_SOURCE_WRITE_BLOCK == flush_source) {
     internal_flush(false, on_finish);
     return;
   }

diff --git a/src/librbd/cache/pwl/Builder.h b/src/librbd/cache/pwl/Builder.h
index b108d0e1845a739cbf715a81d14a409f07eae6f8..9db28ea68480707af22144ba109a6faad430d45d 100644 (file)
--- a/src/librbd/cache/pwl/Builder.h
+++ b/src/librbd/cache/pwl/Builder.h
@@ -45,6 +45,10 @@ public:
       WriteLogOperationSet &set, uint64_t image_offset_bytes,
       uint64_t write_bytes, uint32_t data_len, CephContext *cct,
       std::shared_ptr<WriteLogEntry> writesame_log_entry) = 0;
+  virtual std::shared_ptr<pwl::DiscardLogOperation> create_discard_log_operation(
+      std::shared_ptr<SyncPoint> sync_point, uint64_t image_offset_bytes,
+      uint64_t write_bytes, uint32_t discard_granularity_bytes,
+      utime_t dispatch_time, PerfCounters *perfcounter, CephContext *cct) = 0;
   virtual C_ReadRequest *create_read_request(CephContext *cct, utime_t arrived,
       PerfCounters *perfcounter, ceph::bufferlist *bl, Context *on_finish) = 0;
 

diff --git a/src/librbd/cache/pwl/LogOperation.cc b/src/librbd/cache/pwl/LogOperation.cc
index 0bb4f092f7ee61df2958a3d4bbd2a3e13e9b4620..701fe14b1a60289ded1a382d8a9ce77ba0dd5659 100644 (file)
--- a/src/librbd/cache/pwl/LogOperation.cc
+++ b/src/librbd/cache/pwl/LogOperation.cc
@@ -284,7 +284,6 @@ DiscardLogOperation::DiscardLogOperation(std::shared_ptr<SyncPoint> sync_point,
                                                 image_offset_bytes,
                                                 write_bytes,
                                                 discard_granularity_bytes)) {
-  on_write_append = sync_point->prior_persisted_gather_new_sub();
   on_write_persist = nullptr;
   log_entry->sync_point_entry->writes++;
   log_entry->sync_point_entry->bytes += write_bytes;
@@ -292,12 +291,6 @@ DiscardLogOperation::DiscardLogOperation(std::shared_ptr<SyncPoint> sync_point,
 
 DiscardLogOperation::~DiscardLogOperation() { }
 
-void DiscardLogOperation::init(uint64_t current_sync_gen, bool persist_on_flush,
-                               uint64_t last_op_sequence_num, Context *write_persist) {
-  log_entry->init(current_sync_gen, persist_on_flush, last_op_sequence_num);
-  this->on_write_persist = write_persist;
-}
-
 std::ostream &DiscardLogOperation::format(std::ostream &os) const {
   os << "(Discard) ";
   GenericWriteLogOperation::format(os);

diff --git a/src/librbd/cache/pwl/LogOperation.h b/src/librbd/cache/pwl/LogOperation.h
index 856c5fd2d9fec3cc5df8a1804330f3b469773111..52f8591b6a656833d1f26373906e583008165116 100644 (file)
--- a/src/librbd/cache/pwl/LogOperation.h
+++ b/src/librbd/cache/pwl/LogOperation.h
@@ -57,6 +57,9 @@ public:
   virtual bool is_writing_op() const {
     return false;
   }
+  virtual void init_op(uint64_t current_sync_gen, bool persist_on_flush,
+                    uint64_t last_op_sequence_num, Context *write_persist,
+                    Context *write_append) {};
   virtual void copy_bl_to_cache_buffer(
       std::vector<WriteBufferAllocation>::iterator allocation) {};
 };
@@ -209,8 +212,6 @@ public:
   bool reserved_allocated() const override {
     return false;
   }
-  void init(uint64_t current_sync_gen, bool persist_on_flush,
-            uint64_t last_op_sequence_num, Context *write_persist);
   std::ostream &format(std::ostream &os) const;
   friend std::ostream &operator<<(std::ostream &os,
                                   const DiscardLogOperation &op);

diff --git a/src/librbd/cache/pwl/ReadRequest.h b/src/librbd/cache/pwl/ReadRequest.h
index c188733e107537a2ebfc4367c466d5c5c3d8c83b..d4b2aee5b374976115a3ad09eb7749474bdd14bc 100644 (file)
--- a/src/librbd/cache/pwl/ReadRequest.h
+++ b/src/librbd/cache/pwl/ReadRequest.h
@@ -11,7 +11,7 @@ namespace librbd {
 namespace cache {
 namespace pwl {
 
-typedef std::vector<pwl::ImageExtentBuf> ImageExtentBufs;
+typedef std::vector<std::shared_ptr<pwl::ImageExtentBuf>> ImageExtentBufs;
 
 class C_ReadRequest : public Context {
 public:
@@ -19,7 +19,9 @@ public:
   ImageExtentBufs read_extents;
   bufferlist miss_bl;
 
-  C_ReadRequest(CephContext *cct, utime_t arrived, PerfCounters *perfcounter, bufferlist *out_bl, Context *on_finish)
+  C_ReadRequest(
+      CephContext *cct, utime_t arrived, PerfCounters *perfcounter,
+      bufferlist *out_bl, Context *on_finish)
     : m_cct(cct), m_on_finish(on_finish), m_out_bl(out_bl),
       m_arrived_time(arrived), m_perfcounter(perfcounter) {}
   ~C_ReadRequest() {}

diff --git a/src/librbd/cache/pwl/Request.cc b/src/librbd/cache/pwl/Request.cc
index 2fa9643aba9cefe6086073bc594f183482ef6afe..5288af9d01ae4e64e95e3b117dd12b008708a556 100644 (file)
--- a/src/librbd/cache/pwl/Request.cc
+++ b/src/librbd/cache/pwl/Request.cc
@@ -417,13 +417,10 @@ void C_DiscardRequest<T>::setup_log_operations() {
   std::lock_guard locker(m_lock);
   GenericWriteLogEntries log_entries;
   for (auto &extent : this->image_extents) {
-    op = std::make_shared<DiscardLogOperation>(pwl.get_current_sync_point(),
-                                               extent.first,
-                                               extent.second,
-                                               m_discard_granularity_bytes,
-                                               this->m_dispatched_time,
-                                               m_perfcounter,
-                                               pwl.get_context());
+    op = pwl.m_builder->create_discard_log_operation(
+        pwl.get_current_sync_point(), extent.first, extent.second,
+        m_discard_granularity_bytes, this->m_dispatched_time, m_perfcounter,
+        pwl.get_context());
     log_entries.emplace_back(op->log_entry);
     break;
   }
@@ -433,6 +430,8 @@ void C_DiscardRequest<T>::setup_log_operations() {
     pwl.inc_last_op_sequence_num();
   }
   auto discard_req = this;
+  Context *on_write_append = pwl.get_current_sync_point()->prior_persisted_gather_new_sub();
+
   Context *on_write_persist = new LambdaContext(
     [this, discard_req](int r) {
       ldout(pwl.get_context(), 20) << "discard_req=" << discard_req
@@ -441,7 +440,8 @@ void C_DiscardRequest<T>::setup_log_operations() {
       discard_req->complete_user_request(r);
       discard_req->release_cell();
     });
-  op->init(current_sync_gen, persist_on_flush, pwl.get_last_op_sequence_num(), on_write_persist);
+  op->init_op(current_sync_gen, persist_on_flush, pwl.get_last_op_sequence_num(),
+              on_write_persist, on_write_append);
   pwl.add_into_log_map(log_entries, this);
 }
 

diff --git a/src/librbd/cache/pwl/Types.h b/src/librbd/cache/pwl/Types.h
index 0f4f9c00182132a0347947373b91a190436d9e85..e6d0e08a922fdc2b8b62f66a41555f45785cc3fe 100644 (file)
--- a/src/librbd/cache/pwl/Types.h
+++ b/src/librbd/cache/pwl/Types.h
@@ -154,7 +154,6 @@ namespace cache {
 namespace pwl {
 
 class ImageExtentBuf;
-typedef std::vector<ImageExtentBuf> ImageExtentBufs;
 
 const int IN_FLIGHT_FLUSH_WRITE_LIMIT = 64;
 const int IN_FLIGHT_FLUSH_BYTES_LIMIT = (1 * 1024 * 1024);

diff --git a/src/librbd/cache/pwl/rwl/Builder.h b/src/librbd/cache/pwl/rwl/Builder.h
index 1321d711b927248dccfa399829c864c834d0d21c..c13c7b5ae9310a90b26376ca9b0aa67d643c3d6b 100644 (file)
--- a/src/librbd/cache/pwl/rwl/Builder.h
+++ b/src/librbd/cache/pwl/rwl/Builder.h
@@ -85,6 +85,14 @@ public:
         set, image_offset_bytes, write_bytes, data_len, cct,
         writesame_log_entry);
   }
+  std::shared_ptr<pwl::DiscardLogOperation> create_discard_log_operation(
+      std::shared_ptr<SyncPoint> sync_point, uint64_t image_offset_bytes,
+      uint64_t write_bytes, uint32_t discard_granularity_bytes,
+      utime_t dispatch_time, PerfCounters *perfcounter, CephContext *cct) {
+    return std::make_shared<DiscardLogOperation>(
+        sync_point, image_offset_bytes, write_bytes, discard_granularity_bytes,
+        dispatch_time, perfcounter, cct);
+  }
   C_ReadRequest *create_read_request(CephContext *cct, utime_t arrived,
       PerfCounters *perfcounter, ceph::bufferlist *bl, Context *on_finish) {
     return new C_ReadRequest(cct, arrived, perfcounter, bl, on_finish);

diff --git a/src/librbd/cache/pwl/rwl/LogOperation.cc b/src/librbd/cache/pwl/rwl/LogOperation.cc
index fdd0cf6fa100d3799ba16d2019efdead70c61f81..53fb917b257f017b94ae792d3958e27846f2dcf4 100644 (file)
--- a/src/librbd/cache/pwl/rwl/LogOperation.cc
+++ b/src/librbd/cache/pwl/rwl/LogOperation.cc
@@ -24,6 +24,15 @@ void WriteLogOperation::copy_bl_to_cache_buffer(
   i.copy((unsigned)log_entry->write_bytes(), (char*)log_entry->cache_buffer);
 }
 
+void DiscardLogOperation::init_op(
+    uint64_t current_sync_gen, bool persist_on_flush,
+    uint64_t last_op_sequence_num, Context *write_persist,
+    Context *write_append) {
+  log_entry->init(current_sync_gen, persist_on_flush, last_op_sequence_num);
+  this->on_write_append = write_append;
+  this->on_write_persist = write_persist;
+}
+
 } // namespace rwl
 } // namespace pwl
 } // namespace cache

diff --git a/src/librbd/cache/pwl/rwl/LogOperation.h b/src/librbd/cache/pwl/rwl/LogOperation.h
index 8134c79a5c7b019c859308a47528ed8a4e3c2fb9..874ac77fbaba6e1cea8a09aa5c19f712c7575288 100644 (file)
--- a/src/librbd/cache/pwl/rwl/LogOperation.h
+++ b/src/librbd/cache/pwl/rwl/LogOperation.h
@@ -32,6 +32,21 @@ public:
           std::vector<WriteBufferAllocation>::iterator allocation) override;
 };
 
+class DiscardLogOperation : public pwl::DiscardLogOperation {
+public:
+  DiscardLogOperation(
+      std::shared_ptr<SyncPoint> sync_point, uint64_t image_offset_bytes,
+      uint64_t write_bytes, uint32_t discard_granularity_bytes,
+      utime_t dispatch_time, PerfCounters *perfcounter, CephContext *cct)
+    : pwl::DiscardLogOperation(sync_point, image_offset_bytes, write_bytes,
+                               discard_granularity_bytes, dispatch_time,
+                               perfcounter, cct) {}
+  void init_op(
+      uint64_t current_sync_gen, bool persist_on_flush,
+      uint64_t last_op_sequence_num, Context *write_persist,
+      Context *write_append) override;
+};
+
 } // namespace rwl
 } // namespace pwl
 } // namespace cache

diff --git a/src/librbd/cache/pwl/rwl/ReadRequest.cc b/src/librbd/cache/pwl/rwl/ReadRequest.cc
index c4530237c5d6f541d3dd2cba73e03e11d7834eac..f91f8e5a7c29a449a96ef72f865ab86605d1b703 100644 (file)
--- a/src/librbd/cache/pwl/rwl/ReadRequest.cc
+++ b/src/librbd/cache/pwl/rwl/ReadRequest.cc
@@ -27,23 +27,23 @@ void C_ReadRequest::finish(int r) {
      * hits.
      */
     uint64_t miss_bl_offset = 0;
-    for (auto &extent : read_extents) {
-      if (extent.m_bl.length()) {
+    for (auto extent : read_extents) {
+      if (extent->m_bl.length()) {
         /* This was a hit */
-        ceph_assert(extent.second == extent.m_bl.length());
+        ceph_assert(extent->second == extent->m_bl.length());
         ++hits;
-        hit_bytes += extent.second;
-        m_out_bl->claim_append(extent.m_bl);
+        hit_bytes += extent->second;
+        m_out_bl->claim_append(extent->m_bl);
       } else {
         /* This was a miss. */
         ++misses;
-        miss_bytes += extent.second;
+        miss_bytes += extent->second;
         bufferlist miss_extent_bl;
-        miss_extent_bl.substr_of(miss_bl, miss_bl_offset, extent.second);
+        miss_extent_bl.substr_of(miss_bl, miss_bl_offset, extent->second);
         /* Add this read miss bufferlist to the output bufferlist */
         m_out_bl->claim_append(miss_extent_bl);
         /* Consume these bytes in the read miss bufferlist */
-        miss_bl_offset += extent.second;
+        miss_bl_offset += extent->second;
       }
     }
   }

diff --git a/src/librbd/cache/pwl/rwl/WriteLog.cc b/src/librbd/cache/pwl/rwl/WriteLog.cc
index 86d12c14f04810ad2624151397cc80eb964b19a3..4cea78dfc8d60a185269d3fd8cc2a375d2ff36d1 100644 (file)
--- a/src/librbd/cache/pwl/rwl/WriteLog.cc
+++ b/src/librbd/cache/pwl/rwl/WriteLog.cc
@@ -76,7 +76,7 @@ void WriteLog<I>::collect_read_extents(
   ceph_assert(hit_bl.length() == entry_hit_length);
 
   /* Add hit extent to read extents */
-  ImageExtentBuf hit_extent_buf(hit_extent, hit_bl);
+  auto hit_extent_buf = std::make_shared<ImageExtentBuf>(hit_extent, hit_bl);
   read_ctx->read_extents.push_back(hit_extent_buf);
 }
 

diff --git a/src/librbd/cache/pwl/ssd/Builder.h b/src/librbd/cache/pwl/ssd/Builder.h
index e761d4815efb129613e26120cbdcf6aeab8dceee..07b3fb8693307882564ac5837791ff66ca7f2279 100644 (file)
--- a/src/librbd/cache/pwl/ssd/Builder.h
+++ b/src/librbd/cache/pwl/ssd/Builder.h
@@ -8,6 +8,7 @@
 #include "LogEntry.h"
 #include "ReadRequest.h"
 #include "Request.h"
+#include "LogOperation.h"
 
 #include "librbd/cache/ImageWriteback.h"
 #include "librbd/cache/pwl/Builder.h"
@@ -84,6 +85,14 @@ public:
         set, image_offset_bytes, write_bytes, data_len, cct,
         writesame_log_entry);
   }
+  std::shared_ptr<pwl::DiscardLogOperation> create_discard_log_operation(
+      std::shared_ptr<SyncPoint> sync_point, uint64_t image_offset_bytes,
+      uint64_t write_bytes, uint32_t discard_granularity_bytes,
+      utime_t dispatch_time, PerfCounters *perfcounter, CephContext *cct) {
+    return std::make_shared<DiscardLogOperation>(
+        sync_point, image_offset_bytes, write_bytes, discard_granularity_bytes,
+        dispatch_time, perfcounter, cct);
+  }
   C_ReadRequest *create_read_request(CephContext *cct, utime_t arrived,
       PerfCounters *perfcounter, ceph::bufferlist *bl, Context *on_finish) {
     return new C_ReadRequest(cct, arrived, perfcounter, bl, on_finish);

diff --git a/src/librbd/cache/pwl/ssd/LogOperation.cc b/src/librbd/cache/pwl/ssd/LogOperation.cc
new file mode 100644 (file)
index 0000000..f759d8a
--- /dev/null
+++ b/src/librbd/cache/pwl/ssd/LogOperation.cc
@@ -0,0 +1,36 @@
+// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
+// vim: ts=8 sw=2 smarttab
+
+#include "LogOperation.h"
+
+#define dout_subsys ceph_subsys_rbd_pwl
+#undef dout_prefix
+#define dout_prefix *_dout << "librbd::cache::pwl::ssd::LogOperation: " \
+                           << this << " " <<  __func__ << ": "
+
+namespace librbd {
+namespace cache {
+namespace pwl {
+namespace ssd {
+
+void DiscardLogOperation::init_op(
+    uint64_t current_sync_gen, bool persist_on_flush,
+    uint64_t last_op_sequence_num, Context *write_persist,
+    Context *write_append) {
+  log_entry->init(current_sync_gen, persist_on_flush, last_op_sequence_num);
+  if (persist_on_flush) {
+    this->on_write_append = new LambdaContext(
+        [this, write_persist, write_append] (int r) {
+        write_append->complete(r);
+        write_persist->complete(r);
+        });
+  } else {
+    this->on_write_append = write_append;
+    this->on_write_persist = write_persist;
+  }
+}
+
+} // namespace ssd
+} // namespace pwl
+} // namespace cache
+} // namespace librbd

diff --git a/src/librbd/cache/pwl/ssd/LogOperation.h b/src/librbd/cache/pwl/ssd/LogOperation.h
new file mode 100644 (file)
index 0000000..dbc89aa
--- /dev/null
+++ b/src/librbd/cache/pwl/ssd/LogOperation.h
@@ -0,0 +1,35 @@
+// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
+// vim: ts=8 sw=2 smarttab
+
+#ifndef CEPH_LIBRBD_CACHE_PWL_SSD_LOG_OPERATION_H
+#define CEPH_LIBRBD_CACHE_PWL_SSD_LOG_OPERATION_H
+
+#include "librbd/cache/pwl/LogOperation.h"
+
+
+namespace librbd {
+namespace cache {
+namespace pwl {
+namespace ssd {
+
+class DiscardLogOperation : public pwl::DiscardLogOperation {
+public:
+  DiscardLogOperation(
+      std::shared_ptr<SyncPoint> sync_point, uint64_t image_offset_bytes,
+      uint64_t write_bytes, uint32_t discard_granularity_bytes,
+      utime_t dispatch_time, PerfCounters *perfcounter, CephContext *cct)
+    : pwl::DiscardLogOperation(sync_point, image_offset_bytes, write_bytes,
+                               discard_granularity_bytes, dispatch_time,
+                               perfcounter, cct) {}
+  void init_op(
+      uint64_t current_sync_gen, bool persist_on_flush,
+      uint64_t last_op_sequence_num, Context *write_persist,
+      Context *write_append) override;
+};
+
+} // namespace ssd
+} // namespace pwl
+} // namespace cache
+} // namespace librbd
+
+#endif // CEPH_LIBRBD_CACHE_PWL_SSD_LOG_OPERATION_H

diff --git a/src/librbd/cache/pwl/ssd/ReadRequest.cc b/src/librbd/cache/pwl/ssd/ReadRequest.cc
index c04fdd83cd25ef930074e174f1d3d9aa482fb00b..1a80a8d8ca73c3ab565a202e1a9dbc8ca462cd36 100644 (file)
--- a/src/librbd/cache/pwl/ssd/ReadRequest.cc
+++ b/src/librbd/cache/pwl/ssd/ReadRequest.cc
@@ -27,45 +27,45 @@ void C_ReadRequest::finish(int r) {
        * hits.
        */
     uint64_t miss_bl_offset = 0;
-    for (auto &extent : read_extents) {
-      if (extent.m_bl.length()) {
+    for (auto extent : read_extents) {
+      if (extent->m_bl.length()) {
         /* This was a hit */
         bufferlist data_bl;
-        if (extent.writesame) {
-          int data_len = extent.m_bl.length();
-          int read_buffer_offset = extent.truncate_offset;
-          if (extent.need_to_truncate && extent.truncate_offset >= data_len) {
-            read_buffer_offset = (extent.truncate_offset) % data_len;
+        if (extent->writesame) {
+          int data_len = extent->m_bl.length();
+          int read_buffer_offset = extent->truncate_offset;
+          if (extent->need_to_truncate && extent->truncate_offset >= data_len) {
+            read_buffer_offset = (extent->truncate_offset) % data_len;
           }
           // build data and truncate
           bufferlist temp_bl;
-          uint64_t total_left_bytes = read_buffer_offset + extent.second;
+          uint64_t total_left_bytes = read_buffer_offset + extent->second;
           while (total_left_bytes > 0) {
-            temp_bl.append(extent.m_bl);
+            temp_bl.append(extent->m_bl);
             total_left_bytes = total_left_bytes - data_len;
           }
-          data_bl.substr_of(temp_bl, read_buffer_offset, extent.second);
+          data_bl.substr_of(temp_bl, read_buffer_offset, extent->second);
           m_out_bl->claim_append(data_bl);
-        } else if (extent.need_to_truncate) {
-          assert(extent.m_bl.length() >= extent.truncate_offset + extent.second);
-          data_bl.substr_of(extent.m_bl, extent.truncate_offset, extent.second);
+        } else if (extent->need_to_truncate) {
+          assert(extent->m_bl.length() >= extent->truncate_offset + extent->second);
+          data_bl.substr_of(extent->m_bl, extent->truncate_offset, extent->second);
           m_out_bl->claim_append(data_bl);
         } else {
-          assert(extent.second == extent.m_bl.length());
-          m_out_bl->claim_append(extent.m_bl);
+          assert(extent->second == extent->m_bl.length());
+          m_out_bl->claim_append(extent->m_bl);
         }
         ++hits;
-        hit_bytes += extent.second;
+        hit_bytes += extent->second;
       } else {
         /* This was a miss. */
         ++misses;
-        miss_bytes += extent.second;
+        miss_bytes += extent->second;
         bufferlist miss_extent_bl;
-        miss_extent_bl.substr_of(miss_bl, miss_bl_offset, extent.second);
+        miss_extent_bl.substr_of(miss_bl, miss_bl_offset, extent->second);
         /* Add this read miss bufferlist to the output bufferlist */
         m_out_bl->claim_append(miss_extent_bl);
         /* Consume these bytes in the read miss bufferlist */
-        miss_bl_offset += extent.second;
+        miss_bl_offset += extent->second;
       }
     }
   }

diff --git a/src/librbd/cache/pwl/ssd/WriteLog.cc b/src/librbd/cache/pwl/ssd/WriteLog.cc
index 611f320bc3ce4b49ffc68ee43454263ec71b85a4..725039a81f659aba0492631666555ec4dd8c8fd8 100644 (file)
--- a/src/librbd/cache/pwl/ssd/WriteLog.cc
+++ b/src/librbd/cache/pwl/ssd/WriteLog.cc
@@ -64,27 +64,21 @@ void WriteLog<I>::collect_read_extents(
     uint64_t entry_hit_length, Extent hit_extent,
     pwl::C_ReadRequest *read_ctx) {
     // Make a bl for this hit extent. This will add references to the
-    // write_entry->pmem_bp */
+    // write_entry->cache_bl */
+    ldout(m_image_ctx.cct, 5) << dendl;
     auto write_entry = static_pointer_cast<WriteLogEntry>(map_entry.log_entry);
     buffer::list hit_bl;
     hit_bl = write_entry->get_cache_bl();
+    bool writesame = write_entry->is_writesame_entry();
+    auto hit_extent_buf = std::make_shared<ImageExtentBuf>(
+        hit_extent, hit_bl, true, read_buffer_offset, writesame);
+    read_ctx->read_extents.push_back(hit_extent_buf);
 
     if(!hit_bl.length()) {
-      ImageExtentBuf hit_extent_buf;
-      bool writesame = write_entry->is_writesame_entry();
-      hit_extent_buf = ImageExtentBuf(
-          {hit_extent, true, read_buffer_offset, writesame});
-      read_ctx->read_extents.push_back(hit_extent_buf);
-      ImageExtentBuf &read_extent = read_ctx->read_extents.back();
-
+      ldout(m_image_ctx.cct, 5) << "didn't hit RAM" << dendl;
+      auto read_extent = read_ctx->read_extents.back();
       log_entries_to_read.push_back(&write_entry->ram_entry);
-      bls_to_read.push_back(&read_extent.m_bl);
-    } else {
-      buffer::list new_bl;
-      new_bl.substr_of(hit_bl, read_buffer_offset, entry_hit_length);
-      assert(new_bl.length() == entry_hit_length);
-      ImageExtentBuf hit_extent_buf(hit_extent, new_bl);
-      read_ctx->read_extents.push_back(hit_extent_buf);
+      bls_to_read.push_back(&read_extent->m_bl);
     }
 }
 

diff --git a/src/test/librbd/cache/pwl/test_mock_SSDWriteLog.cc b/src/test/librbd/cache/pwl/test_mock_SSDWriteLog.cc
index 658cb1de34a3ad16444c3d3b64162d5b7304db0f..822aebb0cbcdc0d77c2ec986407625fa4ba8d903 100644 (file)
--- a/src/test/librbd/cache/pwl/test_mock_SSDWriteLog.cc
+++ b/src/test/librbd/cache/pwl/test_mock_SSDWriteLog.cc
@@ -67,9 +67,9 @@ struct TestMockCacheSSDWriteLog : public TestMockFixture {
 
   MockImageCacheStateSSD *get_cache_state(
       MockImageCtx& mock_image_ctx, MockApi& mock_api) {
-    MockImageCacheStateSSD *rwl_state = new MockImageCacheStateSSD(
+    MockImageCacheStateSSD *ssd_state = new MockImageCacheStateSSD(
         &mock_image_ctx, mock_api);
-    return rwl_state;
+    return ssd_state;
   }
 
   void validate_cache_state(librbd::ImageCtx *image_ctx,
@@ -184,7 +184,7 @@ TEST_F(TestMockCacheSSDWriteLog, init_shutdown) {
   MockImageCtx mock_image_ctx(*ictx);
   MockImageWriteback mock_image_writeback(mock_image_ctx);
   MockApi mock_api;
-  MockSSDWriteLog rwl(
+  MockSSDWriteLog ssd(
       mock_image_ctx, get_cache_state(mock_image_ctx, mock_api),
       mock_image_writeback, mock_api);
   MockContextSSD finish_ctx1;
@@ -192,12 +192,12 @@ TEST_F(TestMockCacheSSDWriteLog, init_shutdown) {
   expect_metadata_set(mock_image_ctx);
 
   expect_context_complete(finish_ctx1, 0);
-  rwl.init(&finish_ctx1);
+  ssd.init(&finish_ctx1);
   ASSERT_EQ(0, finish_ctx1.wait());
 
   MockContextSSD finish_ctx2;
   expect_context_complete(finish_ctx2, 0);
-  rwl.shut_down(&finish_ctx2);
+  ssd.shut_down(&finish_ctx2);
   ASSERT_EQ(0, finish_ctx2.wait());
 }
 
@@ -208,7 +208,7 @@ TEST_F(TestMockCacheSSDWriteLog, write) {
   MockImageCtx mock_image_ctx(*ictx);
   MockImageWriteback mock_image_writeback(mock_image_ctx);
   MockApi mock_api;
-  MockSSDWriteLog rwl(
+  MockSSDWriteLog ssd(
       mock_image_ctx, get_cache_state(mock_image_ctx, mock_api),
       mock_image_writeback, mock_api);
 
@@ -216,7 +216,7 @@ TEST_F(TestMockCacheSSDWriteLog, write) {
   expect_op_work_queue(mock_image_ctx);
   expect_metadata_set(mock_image_ctx);
   expect_context_complete(finish_ctx1, 0);
-  rwl.init(&finish_ctx1);
+  ssd.init(&finish_ctx1);
   ASSERT_EQ(0, finish_ctx1.wait());
 
   MockContextSSD finish_ctx2;
@@ -225,23 +225,23 @@ TEST_F(TestMockCacheSSDWriteLog, write) {
   bufferlist bl;
   bl.append(std::string(4096, '1'));
   int fadvise_flags = 0;
-  rwl.write(std::move(image_extents), std::move(bl), fadvise_flags, &finish_ctx2);
+  ssd.write(std::move(image_extents), std::move(bl), fadvise_flags, &finish_ctx2);
   ASSERT_EQ(0, finish_ctx2.wait());
 
   MockContextSSD finish_ctx3;
   expect_context_complete(finish_ctx3, 0);
-  rwl.shut_down(&finish_ctx3);
+  ssd.shut_down(&finish_ctx3);
   ASSERT_EQ(0, finish_ctx3.wait());
 }
 
-TEST_F(TestMockCacheSSDWriteLog, read_hit_rwl_cache) {
+TEST_F(TestMockCacheSSDWriteLog, read_hit_ssd_cache) {
   librbd::ImageCtx *ictx;
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   MockImageCtx mock_image_ctx(*ictx);
   MockImageWriteback mock_image_writeback(mock_image_ctx);
   MockApi mock_api;
-  MockSSDWriteLog rwl(
+  MockSSDWriteLog ssd(
       mock_image_ctx, get_cache_state(mock_image_ctx, mock_api),
       mock_image_writeback, mock_api);
   expect_op_work_queue(mock_image_ctx);
@@ -249,7 +249,7 @@ TEST_F(TestMockCacheSSDWriteLog, read_hit_rwl_cache) {
 
   MockContextSSD finish_ctx1;
   expect_context_complete(finish_ctx1, 0);
-  rwl.init(&finish_ctx1);
+  ssd.init(&finish_ctx1);
   ASSERT_EQ(0, finish_ctx1.wait());
 
   MockContextSSD finish_ctx2;
@@ -259,7 +259,7 @@ TEST_F(TestMockCacheSSDWriteLog, read_hit_rwl_cache) {
   bl.append(std::string(4096, '1'));
   bufferlist bl_copy = bl;
   int fadvise_flags = 0;
-  rwl.write(std::move(image_extents), std::move(bl),
+  ssd.write(std::move(image_extents), std::move(bl),
             fadvise_flags, &finish_ctx2);
   ASSERT_EQ(0, finish_ctx2.wait());
 
@@ -267,7 +267,7 @@ TEST_F(TestMockCacheSSDWriteLog, read_hit_rwl_cache) {
   expect_context_complete(finish_ctx_read, 0);
   Extents image_extents_read{{0, 4096}};
   bufferlist read_bl;
-  rwl.read(std::move(image_extents_read), &read_bl,
+  ssd.read(std::move(image_extents_read), &read_bl,
                      fadvise_flags, &finish_ctx_read);
   ASSERT_EQ(0, finish_ctx_read.wait());
   ASSERT_EQ(4096, read_bl.length());
@@ -275,18 +275,18 @@ TEST_F(TestMockCacheSSDWriteLog, read_hit_rwl_cache) {
 
   MockContextSSD finish_ctx3;
   expect_context_complete(finish_ctx3, 0);
-  rwl.shut_down(&finish_ctx3);
+  ssd.shut_down(&finish_ctx3);
   ASSERT_EQ(0, finish_ctx3.wait());
 }
 
-TEST_F(TestMockCacheSSDWriteLog, read_hit_part_rwl_cache) {
+TEST_F(TestMockCacheSSDWriteLog, read_hit_part_ssd_cache) {
   librbd::ImageCtx *ictx;
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   MockImageCtx mock_image_ctx(*ictx);
   MockImageWriteback mock_image_writeback(mock_image_ctx);
   MockApi mock_api;
-  MockSSDWriteLog rwl(
+  MockSSDWriteLog ssd(
       mock_image_ctx, get_cache_state(mock_image_ctx, mock_api),
       mock_image_writeback, mock_api);
   expect_op_work_queue(mock_image_ctx);
@@ -294,7 +294,7 @@ TEST_F(TestMockCacheSSDWriteLog, read_hit_part_rwl_cache) {
 
   MockContextSSD finish_ctx1;
   expect_context_complete(finish_ctx1, 0);
-  rwl.init(&finish_ctx1);
+  ssd.init(&finish_ctx1);
   ASSERT_EQ(0, finish_ctx1.wait());
 
   MockContextSSD finish_ctx2;
@@ -304,7 +304,7 @@ TEST_F(TestMockCacheSSDWriteLog, read_hit_part_rwl_cache) {
   bl.append(std::string(8192, '1'));
   bufferlist bl_copy = bl;
   int fadvise_flags = 0;
-  rwl.write(std::move(image_extents), std::move(bl),
+  ssd.write(std::move(image_extents), std::move(bl),
             fadvise_flags, &finish_ctx2);
   ASSERT_EQ(0, finish_ctx2.wait());
 
@@ -314,7 +314,7 @@ TEST_F(TestMockCacheSSDWriteLog, read_hit_part_rwl_cache) {
   bl_copy.begin(4095).copy(4096, hit_bl);
   expect_context_complete(finish_ctx_read, 0);
   bufferlist read_bl;
-  rwl.read(std::move(image_extents_read), &read_bl,
+  ssd.read(std::move(image_extents_read), &read_bl,
                      fadvise_flags, &finish_ctx_read);
   ASSERT_EQ(0, finish_ctx_read.wait());
   ASSERT_EQ(4096, read_bl.length());
@@ -324,18 +324,18 @@ TEST_F(TestMockCacheSSDWriteLog, read_hit_part_rwl_cache) {
 
   MockContextSSD finish_ctx3;
   expect_context_complete(finish_ctx3, 0);
-  rwl.shut_down(&finish_ctx3);
+  ssd.shut_down(&finish_ctx3);
   ASSERT_EQ(0, finish_ctx3.wait());
 }
 
-TEST_F(TestMockCacheSSDWriteLog, read_miss_rwl_cache) {
+TEST_F(TestMockCacheSSDWriteLog, read_miss_ssd_cache) {
   librbd::ImageCtx *ictx;
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   MockImageCtx mock_image_ctx(*ictx);
   MockImageWriteback mock_image_writeback(mock_image_ctx);
   MockApi mock_api;
-  MockSSDWriteLog rwl(
+  MockSSDWriteLog ssd(
       mock_image_ctx, get_cache_state(mock_image_ctx, mock_api),
       mock_image_writeback, mock_api);
   expect_op_work_queue(mock_image_ctx);
@@ -343,7 +343,7 @@ TEST_F(TestMockCacheSSDWriteLog, read_miss_rwl_cache) {
 
   MockContextSSD finish_ctx1;
   expect_context_complete(finish_ctx1, 0);
-  rwl.init(&finish_ctx1);
+  ssd.init(&finish_ctx1);
   ASSERT_EQ(0, finish_ctx1.wait());
 
   MockContextSSD finish_ctx2;
@@ -352,7 +352,7 @@ TEST_F(TestMockCacheSSDWriteLog, read_miss_rwl_cache) {
   bufferlist bl;
   bl.append(std::string(4096, '1'));
   int fadvise_flags = 0;
-  rwl.write(std::move(image_extents), std::move(bl),
+  ssd.write(std::move(image_extents), std::move(bl),
             fadvise_flags, &finish_ctx2);
   ASSERT_EQ(0, finish_ctx2.wait());
 
@@ -361,14 +361,14 @@ TEST_F(TestMockCacheSSDWriteLog, read_miss_rwl_cache) {
   expect_context_complete(finish_ctx_read, 4096);
   bufferlist read_bl;
   ASSERT_EQ(0, read_bl.length());
-  rwl.read(std::move(image_extents_read), &read_bl,
+  ssd.read(std::move(image_extents_read), &read_bl,
                      fadvise_flags, &finish_ctx_read);
   ASSERT_EQ(4096, finish_ctx_read.wait());
   ASSERT_EQ(4096, read_bl.length());
 
   MockContextSSD finish_ctx3;
   expect_context_complete(finish_ctx3, 0);
-  rwl.shut_down(&finish_ctx3);
+  ssd.shut_down(&finish_ctx3);
   ASSERT_EQ(0, finish_ctx3.wait());
 }
 
@@ -379,7 +379,7 @@ TEST_F(TestMockCacheSSDWriteLog, compare_and_write_compare_matched) {
   MockImageCtx mock_image_ctx(*ictx);
   MockImageWriteback mock_image_writeback(mock_image_ctx);
   MockApi mock_api;
-  MockSSDWriteLog rwl(
+  MockSSDWriteLog ssd(
       mock_image_ctx, get_cache_state(mock_image_ctx, mock_api),
       mock_image_writeback, mock_api);
   expect_op_work_queue(mock_image_ctx);
@@ -387,7 +387,7 @@ TEST_F(TestMockCacheSSDWriteLog, compare_and_write_compare_matched) {
 
   MockContextSSD finish_ctx1;
   expect_context_complete(finish_ctx1, 0);
-  rwl.init(&finish_ctx1);
+  ssd.init(&finish_ctx1);
   ASSERT_EQ(0, finish_ctx1.wait());
 
   MockContextSSD finish_ctx2;
@@ -397,7 +397,7 @@ TEST_F(TestMockCacheSSDWriteLog, compare_and_write_compare_matched) {
   bl1.append(std::string(4096, '1'));
   bufferlist com_bl = bl1;
   int fadvise_flags = 0;
-  rwl.write(std::move(image_extents), std::move(bl1), fadvise_flags, &finish_ctx2);
+  ssd.write(std::move(image_extents), std::move(bl1), fadvise_flags, &finish_ctx2);
   ASSERT_EQ(0, finish_ctx2.wait());
 
   MockContextSSD finish_ctx_cw;
@@ -406,7 +406,7 @@ TEST_F(TestMockCacheSSDWriteLog, compare_and_write_compare_matched) {
   bufferlist bl2_copy = bl2;
   uint64_t mismatch_offset = -1;
   expect_context_complete(finish_ctx_cw, 0);
-  rwl.compare_and_write({{0, 4096}}, std::move(com_bl), std::move(bl2),
+  ssd.compare_and_write({{0, 4096}}, std::move(com_bl), std::move(bl2),
                             &mismatch_offset, fadvise_flags, &finish_ctx_cw);
   ASSERT_EQ(0, finish_ctx_cw.wait());
   ASSERT_EQ(0, mismatch_offset);
@@ -414,14 +414,14 @@ TEST_F(TestMockCacheSSDWriteLog, compare_and_write_compare_matched) {
   MockContextSSD finish_ctx_read;
   bufferlist read_bl;
   expect_context_complete(finish_ctx_read, 0);
-  rwl.read({{0, 4096}}, &read_bl, fadvise_flags, &finish_ctx_read);
+  ssd.read({{0, 4096}}, &read_bl, fadvise_flags, &finish_ctx_read);
   ASSERT_EQ(0, finish_ctx_read.wait());
   ASSERT_EQ(4096, read_bl.length());
   ASSERT_TRUE(bl2_copy.contents_equal(read_bl));
 
   MockContextSSD finish_ctx3;
   expect_context_complete(finish_ctx3, 0);
-  rwl.shut_down(&finish_ctx3);
+  ssd.shut_down(&finish_ctx3);
 
   ASSERT_EQ(0, finish_ctx3.wait());
 }
@@ -433,7 +433,7 @@ TEST_F(TestMockCacheSSDWriteLog, compare_and_write_compare_failed) {
   MockImageCtx mock_image_ctx(*ictx);
   MockImageWriteback mock_image_writeback(mock_image_ctx);
   MockApi mock_api;
-  MockSSDWriteLog rwl(
+  MockSSDWriteLog ssd(
       mock_image_ctx, get_cache_state(mock_image_ctx, mock_api),
       mock_image_writeback, mock_api);
   expect_op_work_queue(mock_image_ctx);
@@ -441,7 +441,7 @@ TEST_F(TestMockCacheSSDWriteLog, compare_and_write_compare_failed) {
 
   MockContextSSD finish_ctx1;
   expect_context_complete(finish_ctx1, 0);
-  rwl.init(&finish_ctx1);
+  ssd.init(&finish_ctx1);
   ASSERT_EQ(0, finish_ctx1.wait());
 
   MockContextSSD finish_ctx2;
@@ -451,7 +451,7 @@ TEST_F(TestMockCacheSSDWriteLog, compare_and_write_compare_failed) {
   bl1.append(std::string(4096, '1'));
   bufferlist bl1_copy = bl1;
   int fadvise_flags = 0;
-  rwl.write(std::move(image_extents), std::move(bl1), fadvise_flags, &finish_ctx2);
+  ssd.write(std::move(image_extents), std::move(bl1), fadvise_flags, &finish_ctx2);
   ASSERT_EQ(0, finish_ctx2.wait());
 
   MockContextSSD finish_ctx_cw;
@@ -460,7 +460,7 @@ TEST_F(TestMockCacheSSDWriteLog, compare_and_write_compare_failed) {
   bufferlist com_bl = bl2;
   uint64_t mismatch_offset = -1;
   expect_context_complete(finish_ctx_cw, -EILSEQ);
-  rwl.compare_and_write({{0, 4096}}, std::move(com_bl), std::move(bl2),
+  ssd.compare_and_write({{0, 4096}}, std::move(com_bl), std::move(bl2),
                             &mismatch_offset, fadvise_flags, &finish_ctx_cw);
   ASSERT_EQ(-EILSEQ, finish_ctx_cw.wait());
   ASSERT_EQ(0, mismatch_offset);
@@ -468,14 +468,14 @@ TEST_F(TestMockCacheSSDWriteLog, compare_and_write_compare_failed) {
   MockContextSSD finish_ctx_read;
   bufferlist read_bl;
   expect_context_complete(finish_ctx_read, 0);
-  rwl.read({{0, 4096}}, &read_bl, fadvise_flags, &finish_ctx_read);
+  ssd.read({{0, 4096}}, &read_bl, fadvise_flags, &finish_ctx_read);
   ASSERT_EQ(0, finish_ctx_read.wait());
   ASSERT_EQ(4096, read_bl.length());
   ASSERT_TRUE(bl1_copy.contents_equal(read_bl));
 
   MockContextSSD finish_ctx3;
   expect_context_complete(finish_ctx3, 0);
-  rwl.shut_down(&finish_ctx3);
+  ssd.shut_down(&finish_ctx3);
   ASSERT_EQ(0, finish_ctx3.wait());
 }
 
@@ -486,7 +486,7 @@ TEST_F(TestMockCacheSSDWriteLog, writesame) {
   MockImageCtx mock_image_ctx(*ictx);
   MockImageWriteback mock_image_writeback(mock_image_ctx);
   MockApi mock_api;
-  MockSSDWriteLog rwl(
+  MockSSDWriteLog ssd(
       mock_image_ctx, get_cache_state(mock_image_ctx, mock_api),
       mock_image_writeback, mock_api);
   expect_op_work_queue(mock_image_ctx);
@@ -494,7 +494,7 @@ TEST_F(TestMockCacheSSDWriteLog, writesame) {
 
   MockContextSSD finish_ctx1;
   expect_context_complete(finish_ctx1, 0);
-  rwl.init(&finish_ctx1);
+  ssd.init(&finish_ctx1);
   ASSERT_EQ(0, finish_ctx1.wait());
 
   MockContextSSD finish_ctx2;
@@ -503,20 +503,20 @@ TEST_F(TestMockCacheSSDWriteLog, writesame) {
   bl.append(std::string(512, '1'));
   test_bl.append(std::string(4096, '1'));
   int fadvise_flags = 0;
-  rwl.writesame(0, 4096, std::move(bl), fadvise_flags, &finish_ctx2);
+  ssd.writesame(0, 4096, std::move(bl), fadvise_flags, &finish_ctx2);
   ASSERT_EQ(0, finish_ctx2.wait());
 
   MockContextSSD finish_ctx_read;
   bufferlist read_bl;
   expect_context_complete(finish_ctx_read, 0);
-  rwl.read({{0, 4096}}, &read_bl, fadvise_flags, &finish_ctx_read);
+  ssd.read({{0, 4096}}, &read_bl, fadvise_flags, &finish_ctx_read);
   ASSERT_EQ(0, finish_ctx_read.wait());
   ASSERT_EQ(4096, read_bl.length());
   ASSERT_TRUE(test_bl.contents_equal(read_bl));
 
   MockContextSSD finish_ctx3;
   expect_context_complete(finish_ctx3, 0);
-  rwl.shut_down(&finish_ctx3);
+  ssd.shut_down(&finish_ctx3);
 
   ASSERT_EQ(0, finish_ctx3.wait());
 }
@@ -528,7 +528,7 @@ TEST_F(TestMockCacheSSDWriteLog, discard) {
   MockImageCtx mock_image_ctx(*ictx);
   MockImageWriteback mock_image_writeback(mock_image_ctx);
   MockApi mock_api;
-  MockSSDWriteLog rwl(
+  MockSSDWriteLog ssd(
       mock_image_ctx, get_cache_state(mock_image_ctx, mock_api),
       mock_image_writeback, mock_api);
   expect_op_work_queue(mock_image_ctx);
@@ -536,7 +536,7 @@ TEST_F(TestMockCacheSSDWriteLog, discard) {
 
   MockContextSSD finish_ctx1;
   expect_context_complete(finish_ctx1, 0);
-  rwl.init(&finish_ctx1);
+  ssd.init(&finish_ctx1);
   ASSERT_EQ(0, finish_ctx1.wait());
 
   MockContextSSD finish_ctx2;
@@ -546,25 +546,25 @@ TEST_F(TestMockCacheSSDWriteLog, discard) {
   bl.append(std::string(4096, '1'));
   bufferlist bl_copy = bl;
   int fadvise_flags = 0;
-  rwl.write(std::move(image_extents), std::move(bl), fadvise_flags, &finish_ctx2);
+  ssd.write(std::move(image_extents), std::move(bl), fadvise_flags, &finish_ctx2);
   ASSERT_EQ(0, finish_ctx2.wait());
 
   MockContextSSD finish_ctx_discard;
   expect_context_complete(finish_ctx_discard, 0);
-  rwl.discard(0, 4096, 1, &finish_ctx_discard);
+  ssd.discard(0, 4096, 1, &finish_ctx_discard);
   ASSERT_EQ(0, finish_ctx_discard.wait());
 
   MockContextSSD finish_ctx_read;
   bufferlist read_bl;
   expect_context_complete(finish_ctx_read, 0);
-  rwl.read({{0, 4096}}, &read_bl, fadvise_flags, &finish_ctx_read);
+  ssd.read({{0, 4096}}, &read_bl, fadvise_flags, &finish_ctx_read);
   ASSERT_EQ(0, finish_ctx_read.wait());
   ASSERT_EQ(4096, read_bl.length());
   ASSERT_TRUE(read_bl.is_zero());
 
   MockContextSSD finish_ctx3;
   expect_context_complete(finish_ctx3, 0);
-  rwl.shut_down(&finish_ctx3);
+  ssd.shut_down(&finish_ctx3);
 
   ASSERT_EQ(0, finish_ctx3.wait());
 }
@@ -576,7 +576,7 @@ TEST_F(TestMockCacheSSDWriteLog, invalidate) {
   MockImageCtx mock_image_ctx(*ictx);
   MockImageWriteback mock_image_writeback(mock_image_ctx);
   MockApi mock_api;
-  MockSSDWriteLog rwl(
+  MockSSDWriteLog ssd(
       mock_image_ctx, get_cache_state(mock_image_ctx, mock_api),
       mock_image_writeback, mock_api);
   expect_op_work_queue(mock_image_ctx);
@@ -584,7 +584,7 @@ TEST_F(TestMockCacheSSDWriteLog, invalidate) {
 
   MockContextSSD finish_ctx1;
   expect_context_complete(finish_ctx1, 0);
-  rwl.init(&finish_ctx1);
+  ssd.init(&finish_ctx1);
   ASSERT_EQ(0, finish_ctx1.wait());
 
   MockContextSSD finish_ctx2;
@@ -594,17 +594,17 @@ TEST_F(TestMockCacheSSDWriteLog, invalidate) {
   bl.append(std::string(4096, '1'));
   bufferlist bl_copy = bl;
   int fadvise_flags = 0;
-  rwl.write(std::move(image_extents), std::move(bl), fadvise_flags, &finish_ctx2);
+  ssd.write(std::move(image_extents), std::move(bl), fadvise_flags, &finish_ctx2);
   ASSERT_EQ(0, finish_ctx2.wait());
 
   MockContextSSD finish_ctx_invalidate;
   expect_context_complete(finish_ctx_invalidate, 0);
-  rwl.invalidate(&finish_ctx_invalidate);
+  ssd.invalidate(&finish_ctx_invalidate);
   ASSERT_EQ(0, finish_ctx_invalidate.wait());
 
   MockContextSSD finish_ctx3;
   expect_context_complete(finish_ctx3, 0);
-  rwl.shut_down(&finish_ctx3);
+  ssd.shut_down(&finish_ctx3);
 
   ASSERT_EQ(0, finish_ctx3.wait());
 }
@@ -616,7 +616,7 @@ TEST_F(TestMockCacheSSDWriteLog, flush) {
   MockImageCtx mock_image_ctx(*ictx);
   MockImageWriteback mock_image_writeback(mock_image_ctx);
   MockApi mock_api;
-  MockSSDWriteLog rwl(
+  MockSSDWriteLog ssd(
       mock_image_ctx, get_cache_state(mock_image_ctx, mock_api),
       mock_image_writeback, mock_api);
 
@@ -625,7 +625,7 @@ TEST_F(TestMockCacheSSDWriteLog, flush) {
 
   MockContextSSD finish_ctx1;
   expect_context_complete(finish_ctx1, 0);
-  rwl.init(&finish_ctx1);
+  ssd.init(&finish_ctx1);
   ASSERT_EQ(0, finish_ctx1.wait());
 
   MockContextSSD finish_ctx2;
@@ -635,17 +635,17 @@ TEST_F(TestMockCacheSSDWriteLog, flush) {
   bl.append(std::string(4096, '1'));
   bufferlist bl_copy = bl;
   int fadvise_flags = 0;
-  rwl.write(std::move(image_extents), std::move(bl), fadvise_flags, &finish_ctx2);
+  ssd.write(std::move(image_extents), std::move(bl), fadvise_flags, &finish_ctx2);
   ASSERT_EQ(0, finish_ctx2.wait());
 
   MockContextSSD finish_ctx_flush;
   expect_context_complete(finish_ctx_flush, 0);
-  rwl.flush(&finish_ctx_flush);
+  ssd.flush(&finish_ctx_flush);
   ASSERT_EQ(0, finish_ctx_flush.wait());
 
   MockContextSSD finish_ctx3;
   expect_context_complete(finish_ctx3, 0);
-  rwl.shut_down(&finish_ctx3);
+  ssd.shut_down(&finish_ctx3);
 
   ASSERT_EQ(0, finish_ctx3.wait());
 }
@@ -657,7 +657,7 @@ TEST_F(TestMockCacheSSDWriteLog, flush_source_shutdown) {
   MockImageCtx mock_image_ctx(*ictx);
   MockImageWriteback mock_image_writeback(mock_image_ctx);
   MockApi mock_api;
-  MockSSDWriteLog rwl(
+  MockSSDWriteLog ssd(
       mock_image_ctx, get_cache_state(mock_image_ctx, mock_api),
       mock_image_writeback, mock_api);
 
@@ -666,7 +666,7 @@ TEST_F(TestMockCacheSSDWriteLog, flush_source_shutdown) {
 
   MockContextSSD finish_ctx1;
   expect_context_complete(finish_ctx1, 0);
-  rwl.init(&finish_ctx1);
+  ssd.init(&finish_ctx1);
   ASSERT_EQ(0, finish_ctx1.wait());
 
   MockContextSSD finish_ctx2;
@@ -675,17 +675,17 @@ TEST_F(TestMockCacheSSDWriteLog, flush_source_shutdown) {
   bufferlist bl;
   bl.append(std::string(4096, '1'));
   int fadvise_flags = 0;
-  rwl.write(std::move(image_extents), std::move(bl), fadvise_flags, &finish_ctx2);
+  ssd.write(std::move(image_extents), std::move(bl), fadvise_flags, &finish_ctx2);
   ASSERT_EQ(0, finish_ctx2.wait());
 
   MockContextSSD finish_ctx_flush;
   expect_context_complete(finish_ctx_flush, 0);
-  rwl.flush(io::FLUSH_SOURCE_SHUTDOWN, &finish_ctx_flush);
+  ssd.flush(io::FLUSH_SOURCE_SHUTDOWN, &finish_ctx_flush);
   ASSERT_EQ(0, finish_ctx_flush.wait());
 
   MockContextSSD finish_ctx3;
   expect_context_complete(finish_ctx3, 0);
-  rwl.shut_down(&finish_ctx3);
+  ssd.shut_down(&finish_ctx3);
   ASSERT_EQ(0, finish_ctx3.wait());
 }
 
@@ -697,7 +697,7 @@ TEST_F(TestMockCacheSSDWriteLog, flush_source_internal) {
   MockImageCtx mock_image_ctx(*ictx);
   MockImageWriteback mock_image_writeback(mock_image_ctx);
   MockApi mock_api;
-  MockSSDWriteLog rwl(
+  MockSSDWriteLog ssd(
       mock_image_ctx, get_cache_state(mock_image_ctx, mock_api),
       mock_image_writeback, mock_api);
 
@@ -706,7 +706,7 @@ TEST_F(TestMockCacheSSDWriteLog, flush_source_internal) {
 
   MockContextSSD finish_ctx1;
   expect_context_complete(finish_ctx1, 0);
-  rwl.init(&finish_ctx1);
+  ssd.init(&finish_ctx1);
   ASSERT_EQ(0, finish_ctx1.wait());
 
   MockContextSSD finish_ctx2;
@@ -715,17 +715,17 @@ TEST_F(TestMockCacheSSDWriteLog, flush_source_internal) {
   bufferlist bl;
   bl.append(std::string(4096, '1'));
   int fadvise_flags = 0;
-  rwl.write(std::move(image_extents), std::move(bl), fadvise_flags, &finish_ctx2);
+  ssd.write(std::move(image_extents), std::move(bl), fadvise_flags, &finish_ctx2);
   ASSERT_EQ(0, finish_ctx2.wait());
 
   MockContextSSD finish_ctx_flush;
   expect_context_complete(finish_ctx_flush, 0);
-  rwl.flush(io::FLUSH_SOURCE_INTERNAL, &finish_ctx_flush);
+  ssd.flush(io::FLUSH_SOURCE_INTERNAL, &finish_ctx_flush);
   ASSERT_EQ(0, finish_ctx_flush.wait());
 
   MockContextSSD finish_ctx3;
   expect_context_complete(finish_ctx3, 0);
-  rwl.shut_down(&finish_ctx3);
+  ssd.shut_down(&finish_ctx3);
   ASSERT_EQ(0, finish_ctx3.wait());
 }
 
@@ -736,7 +736,7 @@ TEST_F(TestMockCacheSSDWriteLog, flush_source_user) {
   MockImageCtx mock_image_ctx(*ictx);
   MockImageWriteback mock_image_writeback(mock_image_ctx);
   MockApi mock_api;
-  MockSSDWriteLog rwl(
+  MockSSDWriteLog ssd(
       mock_image_ctx, get_cache_state(mock_image_ctx, mock_api),
       mock_image_writeback, mock_api);
   expect_op_work_queue(mock_image_ctx);
@@ -744,7 +744,7 @@ TEST_F(TestMockCacheSSDWriteLog, flush_source_user) {
 
   MockContextSSD finish_ctx1;
   expect_context_complete(finish_ctx1, 0);
-  rwl.init(&finish_ctx1);
+  ssd.init(&finish_ctx1);
   ASSERT_EQ(0, finish_ctx1.wait());
 
   MockContextSSD finish_ctx2;
@@ -753,13 +753,13 @@ TEST_F(TestMockCacheSSDWriteLog, flush_source_user) {
   bufferlist bl;
   bl.append(std::string(4096, '1'));
   int fadvise_flags = 0;
-  rwl.write(std::move(image_extents), std::move(bl), fadvise_flags, &finish_ctx2);
+  ssd.write(std::move(image_extents), std::move(bl), fadvise_flags, &finish_ctx2);
   ASSERT_EQ(0, finish_ctx2.wait());
 
   usleep(10000);
   MockContextSSD finish_ctx_flush;
   expect_context_complete(finish_ctx_flush, 0);
-  rwl.flush(io::FLUSH_SOURCE_USER, &finish_ctx_flush);
+  ssd.flush(io::FLUSH_SOURCE_USER, &finish_ctx_flush);
   ASSERT_EQ(0, finish_ctx_flush.wait());
 
   MockContextSSD finish_ctx3;
@@ -768,12 +768,12 @@ TEST_F(TestMockCacheSSDWriteLog, flush_source_user) {
   bufferlist bl2;
   bl2.append(std::string(4096, '1'));
   int fadvise_flags2 = 0;
-  rwl.write(std::move(image_extents2), std::move(bl2), fadvise_flags2, &finish_ctx3);
+  ssd.write(std::move(image_extents2), std::move(bl2), fadvise_flags2, &finish_ctx3);
   ASSERT_EQ(0, finish_ctx3.wait());
 
   MockContextSSD finish_ctx4;
   expect_context_complete(finish_ctx4, 0);
-  rwl.shut_down(&finish_ctx4);
+  ssd.shut_down(&finish_ctx4);
   ASSERT_EQ(0, finish_ctx4.wait());
 }