From: Mahati Chamarthy Date: Thu, 11 Feb 2021 10:24:30 +0000 (+0530) Subject: librbd/cache/pwl: Fix IO completion X-Git-Tag: v17.1.0~2661^2 X-Git-Url: http://git-server-git.apps.pok.os.sepia.ceph.com/?a=commitdiff_plain;h=eeb0b405044bfaade49da0cc635bc05fb0286c0f;p=ceph.git 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 --- diff --git a/src/librbd/CMakeLists.txt b/src/librbd/CMakeLists.txt index 0ba78390c8ad..48483a674171 100644 --- a/src/librbd/CMakeLists.txt +++ b/src/librbd/CMakeLists.txt @@ -281,6 +281,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 0c3b7cb1891c..640fead2e189 100644 --- a/src/librbd/cache/pwl/AbstractWriteLog.cc +++ b/src/librbd/cache/pwl/AbstractWriteLog.cc @@ -668,7 +668,6 @@ template void AbstractWriteLog::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::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(miss_extent); read_ctx->read_extents.push_back(miss_extent_buf); extent_offset += miss_extent_length; } @@ -756,6 +755,7 @@ void AbstractWriteLog::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::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( + 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::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(miss_extent); read_ctx->read_extents.push_back(miss_extent_buf); extent_offset += miss_extent_length; } @@ -878,7 +880,8 @@ void AbstractWriteLog::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 b108d0e1845a..9db28ea68480 100644 --- 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 writesame_log_entry) = 0; + virtual std::shared_ptr create_discard_log_operation( + std::shared_ptr 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 0bb4f092f7ee..701fe14b1a60 100644 --- a/src/librbd/cache/pwl/LogOperation.cc +++ b/src/librbd/cache/pwl/LogOperation.cc @@ -284,7 +284,6 @@ DiscardLogOperation::DiscardLogOperation(std::shared_ptr 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 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 856c5fd2d9fe..52f8591b6a65 100644 --- 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::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 c188733e1075..d4b2aee5b374 100644 --- 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 ImageExtentBufs; +typedef std::vector> 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 2fa9643aba9c..5288af9d01ae 100644 --- a/src/librbd/cache/pwl/Request.cc +++ b/src/librbd/cache/pwl/Request.cc @@ -417,13 +417,10 @@ void C_DiscardRequest::setup_log_operations() { std::lock_guard locker(m_lock); GenericWriteLogEntries log_entries; for (auto &extent : this->image_extents) { - op = std::make_shared(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::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::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 0f4f9c001821..e6d0e08a922f 100644 --- 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 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 1321d711b927..c13c7b5ae931 100644 --- 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 create_discard_log_operation( + std::shared_ptr 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( + 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 fdd0cf6fa100..53fb917b257f 100644 --- 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 8134c79a5c7b..874ac77fbaba 100644 --- a/src/librbd/cache/pwl/rwl/LogOperation.h +++ b/src/librbd/cache/pwl/rwl/LogOperation.h @@ -32,6 +32,21 @@ public: std::vector::iterator allocation) override; }; +class DiscardLogOperation : public pwl::DiscardLogOperation { +public: + DiscardLogOperation( + std::shared_ptr 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 c4530237c5d6..f91f8e5a7c29 100644 --- 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 86d12c14f048..4cea78dfc8d6 100644 --- a/src/librbd/cache/pwl/rwl/WriteLog.cc +++ b/src/librbd/cache/pwl/rwl/WriteLog.cc @@ -76,7 +76,7 @@ void WriteLog::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(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 e761d4815efb..07b3fb869330 100644 --- 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 create_discard_log_operation( + std::shared_ptr 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( + 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 index 000000000000..f759d8a8eeec --- /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 index 000000000000..dbc89aa73836 --- /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 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 c04fdd83cd25..1a80a8d8ca73 100644 --- 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 611f320bc3ce..725039a81f65 100644 --- a/src/librbd/cache/pwl/ssd/WriteLog.cc +++ b/src/librbd/cache/pwl/ssd/WriteLog.cc @@ -64,27 +64,21 @@ void WriteLog::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(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( + 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 658cb1de34a3..822aebb0cbcd 100644 --- 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()); }