From: lixiaoy1 Date: Wed, 4 Nov 2020 14:47:01 +0000 (+0800) Subject: librbd/cache: move image writeback cache to plugin X-Git-Tag: v16.1.0~331^2 X-Git-Url: http://git-server-git.apps.pok.os.sepia.ceph.com/?a=commitdiff_plain;h=31377af848b315bf8917207e093958dc0ba37406;p=ceph.git librbd/cache: move image writeback cache to plugin Signed-off-by: Li, Xiaoyan --- diff --git a/src/librbd/CMakeLists.txt b/src/librbd/CMakeLists.txt index 5907859790866..ce95cf8d6e095 100644 --- a/src/librbd/CMakeLists.txt +++ b/src/librbd/CMakeLists.txt @@ -9,10 +9,6 @@ set(librbd_types_srcs watcher/Types.cc WatchNotifyTypes.cc) -if(WITH_RBD_RWL OR WITH_RBD_SSD_CACHE) - list(APPEND librbd_types_srcs cache/pwl/Types.cc) -endif() - add_library(rbd_types STATIC ${librbd_types_srcs}) @@ -53,10 +49,6 @@ set(librbd_internal_srcs cache/ImageWriteback.cc cache/ObjectCacherObjectDispatch.cc cache/ObjectCacherWriteback.cc - cache/pwl/DiscardRequest.cc - cache/pwl/InitRequest.cc - cache/pwl/ShutdownRequest.cc - cache/Utils.cc cache/WriteAroundObjectDispatch.cc crypto/BlockCrypto.cc crypto/CryptoContextPool.cc @@ -212,30 +204,6 @@ if(LINUX AND HAVE_LIBCRYPTSETUP) crypto/luks/LoadRequest.cc) endif() -if(WITH_RBD_RWL OR WITH_RBD_SSD_CACHE) - set(librbd_internal_srcs - ${librbd_internal_srcs} - cache/pwl/ImageCacheState.cc - cache/pwl/LogEntry.cc - cache/pwl/LogMap.cc - cache/pwl/LogOperation.cc - cache/pwl/ReadRequest.cc - cache/pwl/Request.cc - cache/pwl/SyncPoint.cc - cache/pwl/AbstractWriteLog.cc - cache/WriteLogImageDispatch.cc) - if(WITH_RBD_RWL) - set(librbd_internal_srcs - ${librbd_internal_srcs} - cache/pwl/ReplicatedWriteLog.cc) - endif() - if(WITH_RBD_SSD_CACHE) - set(librbd_internal_srcs - ${librbd_internal_srcs} - cache/pwl/SSDWriteLog.cc) - endif() -endif() - add_library(rbd_api STATIC librbd.cc) add_library(rbd_internal STATIC ${librbd_internal_srcs} @@ -258,16 +226,6 @@ if(LINUX AND HAVE_LIBCRYPTSETUP) target_link_libraries(rbd_internal PRIVATE ${LIBCRYPTSETUP_LIBRARIES}) endif() -if(WITH_RBD_RWL OR WITH_RBD_SSD_CACHE) - target_link_libraries(rbd_internal - PUBLIC blk) - target_link_libraries(rbd_internal PRIVATE - StdFilesystem::filesystem) -endif() -if(WITH_RBD_RWL) - target_link_libraries(rbd_types - PUBLIC blk) -endif() add_custom_target(librbd_plugins) set(librbd_plugins_dir ${CEPH_INSTALL_PKGLIBDIR}/librbd) @@ -287,6 +245,56 @@ set_target_properties(librbd_plugin_parent_cache PROPERTIES install(TARGETS librbd_plugin_parent_cache DESTINATION ${librbd_plugins_dir}) add_dependencies(librbd_plugins librbd_plugin_parent_cache) +if(WITH_RBD_RWL OR WITH_RBD_SSD_CACHE) + set(rbd_plugin_pwl_srcs + cache/WriteLogImageDispatch.cc + cache/pwl/AbstractWriteLog.cc + cache/pwl/DiscardRequest.cc + cache/pwl/ImageCacheState.cc + cache/pwl/InitRequest.cc + cache/pwl/LogEntry.cc + cache/pwl/LogMap.cc + cache/pwl/LogOperation.cc + cache/pwl/ReadRequest.cc + cache/pwl/Request.cc + cache/pwl/ShutdownRequest.cc + cache/pwl/SyncPoint.cc + cache/pwl/Types.cc + plugin/WriteLogImageCache.cc) + + if(WITH_RBD_SSD_CACHE) + set(rbd_plugin_pwl_srcs + ${rbd_plugin_pwl_srcs} + cache/pwl/SSDWriteLog.cc) + endif() + if(WITH_RBD_RWL) + set(rbd_plugin_pwl_srcs + ${rbd_plugin_pwl_srcs} + cache/pwl/ReplicatedWriteLog.cc) + endif() + + add_library(librbd_plugin_pwl_cache SHARED + ${rbd_plugin_pwl_srcs}) + target_link_libraries(librbd_plugin_pwl_cache PRIVATE + blk + ceph-common + cls_rbd_client + StdFilesystem::filesystem) + + if(WITH_RBD_RWL) + target_link_libraries(librbd_plugin_pwl_cache + PUBLIC pmem::pmemobj + PRIVATE pmem::pmem) + endif() + + set_target_properties(librbd_plugin_pwl_cache PROPERTIES + OUTPUT_NAME ceph_librbd_pwl_cache + VERSION 1.0.0 + SOVERSION 1) + install(TARGETS librbd_plugin_pwl_cache DESTINATION ${librbd_plugins_dir}) + add_dependencies(librbd_plugins librbd_plugin_pwl_cache) +endif() + add_library(librbd ${CEPH_SHARED} librbd.cc) if(WITH_LTTNG) diff --git a/src/librbd/cache/Utils.cc b/src/librbd/cache/Utils.cc deleted file mode 100644 index c65c57551a5ba..0000000000000 --- a/src/librbd/cache/Utils.cc +++ /dev/null @@ -1,24 +0,0 @@ -// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*- -// vim: ts=8 sw=2 smarttab - -#include "librbd/cache/pwl/DiscardRequest.h" -#include "librbd/cache/Utils.h" -#include "include/Context.h" - -namespace librbd { -namespace cache { -namespace util { - -template -void discard_cache(I &image_ctx, Context *ctx) { - cache::pwl::DiscardRequest *req = cache::pwl::DiscardRequest::create( - image_ctx, ctx); - req->send(); -} - -} // namespace util -} // namespace cache -} // namespace librbd - -template void librbd::cache::util::discard_cache( - librbd::ImageCtx &image_ctx, Context *ctx); diff --git a/src/librbd/cache/Utils.h b/src/librbd/cache/Utils.h index 67c0b6fbc7358..e338899c09e8d 100644 --- a/src/librbd/cache/Utils.h +++ b/src/librbd/cache/Utils.h @@ -24,9 +24,6 @@ bool is_pwl_enabled(T& image_ctx) { #endif // WITH_RBD_RWL } -template -void discard_cache(T &image_ctx, Context *ctx); - } // namespace util } // namespace cache } // namespace librbd diff --git a/src/librbd/cache/WriteLogImageDispatch.cc b/src/librbd/cache/WriteLogImageDispatch.cc index 031e59287d9cd..6cb8738e7f9ef 100644 --- a/src/librbd/cache/WriteLogImageDispatch.cc +++ b/src/librbd/cache/WriteLogImageDispatch.cc @@ -18,16 +18,6 @@ namespace librbd { namespace cache { -namespace { - -void start_in_flight_io(io::AioCompletion* aio_comp) { - if (!aio_comp->async_op.started()) { - aio_comp->start_op(); - } -} - -} // anonymous namespace - template void WriteLogImageDispatch::shut_down(Context* on_finish) { ceph_assert(m_image_cache != nullptr); @@ -39,7 +29,7 @@ void WriteLogImageDispatch::shut_down(Context* on_finish) { }); cache::pwl::ShutdownRequest *req = cache::pwl::ShutdownRequest::create( - *m_image_ctx, m_image_cache, ctx); + *m_image_ctx, m_image_cache, m_plugin_api, ctx); req->send(); } @@ -64,14 +54,9 @@ bool WriteLogImageDispatch::read( return true; } - start_in_flight_io(aio_comp); - - aio_comp->set_request_count(1); - aio_comp->read_result = std::move(read_result); - aio_comp->read_result.set_image_extents(image_extents); + m_plugin_api.update_aio_comp(aio_comp, 1, read_result, image_extents); - auto *req_comp = new io::ReadResult::C_ImageReadRequest( - aio_comp, 0, image_extents); + auto *req_comp = m_plugin_api.create_image_read_request(aio_comp, 0, image_extents); m_image_cache->read(std::move(image_extents), &req_comp->bl, op_flags, @@ -94,10 +79,8 @@ bool WriteLogImageDispatch::write( return true; } - start_in_flight_io(aio_comp); - - aio_comp->set_request_count(1); - io::C_AioRequest *req_comp = new io::C_AioRequest(aio_comp); + m_plugin_api.update_aio_comp(aio_comp, 1); + io::C_AioRequest *req_comp = m_plugin_api.create_aio_request(aio_comp); m_image_cache->write(std::move(image_extents), std::move(bl), op_flags, req_comp); return true; @@ -119,11 +102,9 @@ bool WriteLogImageDispatch::discard( return true; } - start_in_flight_io(aio_comp); - - aio_comp->set_request_count(image_extents.size()); + m_plugin_api.update_aio_comp(aio_comp, image_extents.size()); for (auto &extent : image_extents) { - io::C_AioRequest *req_comp = new io::C_AioRequest(aio_comp); + io::C_AioRequest *req_comp = m_plugin_api.create_aio_request(aio_comp); m_image_cache->discard(extent.first, extent.second, discard_granularity_bytes, req_comp); @@ -147,11 +128,9 @@ bool WriteLogImageDispatch::write_same( return true; } - start_in_flight_io(aio_comp); - - aio_comp->set_request_count(image_extents.size()); + m_plugin_api.update_aio_comp(aio_comp, image_extents.size()); for (auto &extent : image_extents) { - io::C_AioRequest *req_comp = new io::C_AioRequest(aio_comp); + io::C_AioRequest *req_comp = m_plugin_api.create_aio_request(aio_comp); m_image_cache->writesame(extent.first, extent.second, std::move(bl), op_flags, req_comp); @@ -175,10 +154,8 @@ bool WriteLogImageDispatch::compare_and_write( return true; } - start_in_flight_io(aio_comp); - - aio_comp->set_request_count(1); - io::C_AioRequest *req_comp = new io::C_AioRequest(aio_comp); + m_plugin_api.update_aio_comp(aio_comp, 1); + io::C_AioRequest *req_comp = m_plugin_api.create_aio_request(aio_comp); m_image_cache->compare_and_write( std::move(image_extents), std::move(cmp_bl), std::move(bl), mismatch_offset, op_flags, req_comp); @@ -195,12 +172,11 @@ bool WriteLogImageDispatch::flush( auto cct = m_image_ctx->cct; ldout(cct, 20) << "tid=" << tid << dendl; - start_in_flight_io(aio_comp); - *dispatch_result = io::DISPATCH_RESULT_COMPLETE; - aio_comp->set_request_count(1); - io::C_AioRequest *req_comp = new io::C_AioRequest(aio_comp); + m_plugin_api.update_aio_comp(aio_comp, 1); + + io::C_AioRequest *req_comp = m_plugin_api.create_aio_request(aio_comp); m_image_cache->flush(flush_source, req_comp); return true; @@ -223,7 +199,7 @@ bool WriteLogImageDispatch::preprocess_length( io::AioCompletion* aio_comp, io::Extents &image_extents) const { auto total_bytes = io::util::get_extents_length(image_extents); if (total_bytes == 0) { - aio_comp->set_request_count(0); + m_plugin_api.update_aio_comp(aio_comp, 0); return true; } return false; diff --git a/src/librbd/cache/WriteLogImageDispatch.h b/src/librbd/cache/WriteLogImageDispatch.h index d0fb106e3a583..9344916237ed3 100644 --- a/src/librbd/cache/WriteLogImageDispatch.h +++ b/src/librbd/cache/WriteLogImageDispatch.h @@ -10,6 +10,7 @@ #include "common/zipkin_trace.h" #include "librbd/io/ReadResult.h" #include "librbd/io/Types.h" +#include "librbd/plugin/Api.h" struct Context; @@ -25,8 +26,10 @@ template class WriteLogImageDispatch : public io::ImageDispatchInterface { public: WriteLogImageDispatch(ImageCtxT* image_ctx, - pwl::AbstractWriteLog *image_cache) : - m_image_ctx(image_ctx), m_image_cache(image_cache) { + pwl::AbstractWriteLog *image_cache, + plugin::Api& plugin_api) : + m_image_ctx(image_ctx), m_image_cache(image_cache), + m_plugin_api(plugin_api) { } io::ImageDispatchLayer get_dispatch_layer() const override { @@ -91,6 +94,7 @@ public: private: ImageCtxT* m_image_ctx; pwl::AbstractWriteLog *m_image_cache; + plugin::Api& m_plugin_api; bool preprocess_length( io::AioCompletion* aio_comp, io::Extents &image_extents) const; diff --git a/src/librbd/cache/pwl/AbstractWriteLog.cc b/src/librbd/cache/pwl/AbstractWriteLog.cc index fba6300c142ad..d5bac1b509399 100644 --- a/src/librbd/cache/pwl/AbstractWriteLog.cc +++ b/src/librbd/cache/pwl/AbstractWriteLog.cc @@ -18,6 +18,7 @@ #include "librbd/cache/pwl/ImageCacheState.h" #include "librbd/cache/pwl/LogEntry.h" #include "librbd/cache/pwl/ReadRequest.h" +#include "librbd/plugin/Api.h" #include #include @@ -37,24 +38,27 @@ typedef AbstractWriteLog::Extent Extent; typedef AbstractWriteLog::Extents Extents; template -AbstractWriteLog::AbstractWriteLog(I &image_ctx, librbd::cache::pwl::ImageCacheState* cache_state) +AbstractWriteLog::AbstractWriteLog(I &image_ctx, librbd::cache::pwl::ImageCacheState* cache_state, + cache::ImageWritebackInterface& image_writeback, + plugin::Api& plugin_api) : m_write_log_guard(image_ctx.cct), - m_deferred_dispatch_lock(ceph::make_mutex(util::unique_lock_name( + m_deferred_dispatch_lock(ceph::make_mutex(pwl::unique_lock_name( "librbd::cache::pwl::AbstractWriteLog::m_deferred_dispatch_lock", this))), - m_blockguard_lock(ceph::make_mutex(util::unique_lock_name( + m_blockguard_lock(ceph::make_mutex(pwl::unique_lock_name( "librbd::cache::pwl::AbstractWriteLog::m_blockguard_lock", this))), m_thread_pool( image_ctx.cct, "librbd::cache::pwl::AbstractWriteLog::thread_pool", "tp_pwl", 4, ""), m_cache_state(cache_state), m_image_ctx(image_ctx), m_log_pool_config_size(DEFAULT_POOL_SIZE), - m_image_writeback(image_ctx), - m_log_retire_lock(ceph::make_mutex(util::unique_lock_name( + m_image_writeback(image_writeback), + m_plugin_api(plugin_api), + m_log_retire_lock(ceph::make_mutex(pwl::unique_lock_name( "librbd::cache::pwl::AbstractWriteLog::m_log_retire_lock", this))), m_entry_reader_lock("librbd::cache::pwl::AbstractWriteLog::m_entry_reader_lock"), - m_log_append_lock(ceph::make_mutex(util::unique_lock_name( + m_log_append_lock(ceph::make_mutex(pwl::unique_lock_name( "librbd::cache::pwl::AbstractWriteLog::m_log_append_lock", this))), - m_lock(ceph::make_mutex(util::unique_lock_name( + m_lock(ceph::make_mutex(pwl::unique_lock_name( "librbd::cache::pwl::AbstractWriteLog::m_lock", this))), m_blocks_to_log_entries(image_ctx.cct), m_work_queue("librbd::cache::pwl::ReplicatedWriteLog::work_queue", @@ -64,7 +68,7 @@ AbstractWriteLog::AbstractWriteLog(I &image_ctx, librbd::cache::pwl::ImageCac &m_thread_pool) { CephContext *cct = m_image_ctx.cct; - ImageCtx::get_timer_instance(cct, &m_timer, &m_timer_lock); + m_plugin_api.get_image_timer_instance(cct, &m_timer, &m_timer_lock); } template diff --git a/src/librbd/cache/pwl/AbstractWriteLog.h b/src/librbd/cache/pwl/AbstractWriteLog.h index e22bbcb6c8a08..c96eb32686986 100644 --- a/src/librbd/cache/pwl/AbstractWriteLog.h +++ b/src/librbd/cache/pwl/AbstractWriteLog.h @@ -24,6 +24,8 @@ namespace librbd { struct ImageCtx; +namespace plugin { template struct Api; } + namespace cache { namespace pwl { @@ -64,7 +66,9 @@ public: typedef io::Extent Extent; typedef io::Extents Extents; - AbstractWriteLog(ImageCtxT &image_ctx, librbd::cache::pwl::ImageCacheState* cache_state); + AbstractWriteLog(ImageCtxT &image_ctx, librbd::cache::pwl::ImageCacheState* cache_state, + cache::ImageWritebackInterface& image_writeback, + plugin::Api& plugin_api); virtual ~AbstractWriteLog(); AbstractWriteLog(const AbstractWriteLog&) = delete; AbstractWriteLog &operator=(const AbstractWriteLog&) = delete; @@ -253,7 +257,9 @@ protected: std::atomic m_alloc_failed_since_retire = {false}; - ImageWriteback m_image_writeback; + cache::ImageWritebackInterface& m_image_writeback; + plugin::Api& m_plugin_api; + /* * When m_first_free_entry == m_first_valid_entry, the log is * empty. There is always at least one free entry, which can't be diff --git a/src/librbd/cache/pwl/DiscardRequest.cc b/src/librbd/cache/pwl/DiscardRequest.cc index 80ccd5abca072..9f66e077b1f14 100644 --- a/src/librbd/cache/pwl/DiscardRequest.cc +++ b/src/librbd/cache/pwl/DiscardRequest.cc @@ -7,7 +7,6 @@ #include "librbd/asio/ContextWQ.h" #include "librbd/cache/pwl/DiscardRequest.h" -#if defined(WITH_RBD_RWL) #if __has_include() #include namespace fs = std::filesystem; @@ -17,7 +16,6 @@ namespace fs = std::experimental::filesystem; #endif #include "librbd/cache/pwl/ImageCacheState.h" -#endif // WITH_RBD_RWL #include "librbd/cache/Types.h" #include "librbd/io/ImageDispatcherInterface.h" @@ -40,35 +38,33 @@ using librbd::util::create_context_callback; template DiscardRequest* DiscardRequest::create( I &image_ctx, + plugin::Api& plugin_api, Context *on_finish) { - return new DiscardRequest(image_ctx, on_finish); + return new DiscardRequest(image_ctx, plugin_api, on_finish); } template DiscardRequest::DiscardRequest( I &image_ctx, + plugin::Api& plugin_api, Context *on_finish) : m_image_ctx(image_ctx), + m_plugin_api(plugin_api), m_on_finish(create_async_context_callback(image_ctx, on_finish)), m_error_result(0) { } template void DiscardRequest::send() { -#if defined(WITH_RBD_RWL) delete_image_cache_file(); -#else - finish(); -#endif } -#if defined(WITH_RBD_RWL) template void DiscardRequest::delete_image_cache_file() { CephContext *cct = m_image_ctx.cct; ldout(cct, 10) << dendl; - m_cache_state = ImageCacheState::get_image_cache_state(&m_image_ctx); + m_cache_state = ImageCacheState::get_image_cache_state(&m_image_ctx, m_plugin_api); if (!m_cache_state) { remove_feature_bit(); return; @@ -148,16 +144,12 @@ void DiscardRequest::handle_remove_feature_bit(int r) { finish(); } -#endif // WITH_RBD_RWL - template void DiscardRequest::finish() { -#if defined(WITH_RBD_RWL) if (m_cache_state) { delete m_cache_state; m_cache_state = nullptr; } -#endif // WITH_RBD_RWL m_on_finish->complete(m_error_result); delete this; diff --git a/src/librbd/cache/pwl/DiscardRequest.h b/src/librbd/cache/pwl/DiscardRequest.h index 6edd194b7d9c5..c896369fe7f84 100644 --- a/src/librbd/cache/pwl/DiscardRequest.h +++ b/src/librbd/cache/pwl/DiscardRequest.h @@ -9,6 +9,7 @@ class Context; namespace librbd { class ImageCtx; +namespace plugin { template struct Api; } namespace cache { @@ -22,6 +23,7 @@ class DiscardRequest { public: static DiscardRequest* create( ImageCtxT &image_ctx, + plugin::Api& plugin_api, Context *on_finish); void send(); @@ -51,10 +53,12 @@ private: */ DiscardRequest(ImageCtxT &image_ctx, + plugin::Api& plugin_api, Context *on_finish); ImageCtxT &m_image_ctx; ImageCacheState* m_cache_state; + plugin::Api& m_plugin_api; Context *m_on_finish; int m_error_result; diff --git a/src/librbd/cache/pwl/ImageCacheState.cc b/src/librbd/cache/pwl/ImageCacheState.cc index dba7b971d226e..09ebd15b84187 100644 --- a/src/librbd/cache/pwl/ImageCacheState.cc +++ b/src/librbd/cache/pwl/ImageCacheState.cc @@ -10,6 +10,7 @@ #include "common/ceph_json.h" #include "common/environment.h" #include "common/hostname.h" +#include "librbd/plugin/Api.h" #undef dout_subsys #define dout_subsys ceph_subsys_rbd_pwl @@ -33,7 +34,8 @@ bool get_json_format(const std::string& s, JSONFormattable *f) { } // namespace template -ImageCacheState::ImageCacheState(I *image_ctx) : m_image_ctx(image_ctx) { +ImageCacheState::ImageCacheState(I *image_ctx, plugin::Api& plugin_api) : + m_image_ctx(image_ctx), m_plugin_api(plugin_api) { ldout(image_ctx->cct, 20) << "Initialize RWL cache state with config data. " << dendl; @@ -43,7 +45,8 @@ ImageCacheState::ImageCacheState(I *image_ctx) : m_image_ctx(image_ctx) { template ImageCacheState::ImageCacheState( - I *image_ctx, JSONFormattable &f) : m_image_ctx(image_ctx) { + I *image_ctx, JSONFormattable &f, plugin::Api& plugin_api) : + m_image_ctx(image_ctx), m_plugin_api(plugin_api) { ldout(image_ctx->cct, 20) << "Initialize RWL cache state with data from " << "server side"<< dendl; @@ -73,15 +76,16 @@ void ImageCacheState::write_image_cache_state(Context *on_finish) { ldout(m_image_ctx->cct, 20) << __func__ << " Store state: " << image_state_json << dendl; - m_image_ctx->operations->execute_metadata_set(IMAGE_CACHE_STATE, - image_state_json, on_finish); + m_plugin_api.execute_image_metadata_set(m_image_ctx, IMAGE_CACHE_STATE, + image_state_json, on_finish); } template void ImageCacheState::clear_image_cache_state(Context *on_finish) { std::shared_lock owner_lock{m_image_ctx->owner_lock}; ldout(m_image_ctx->cct, 20) << __func__ << " Remove state: " << dendl; - m_image_ctx->operations->execute_metadata_remove(IMAGE_CACHE_STATE, on_finish); + m_plugin_api.execute_image_metadata_remove( + m_image_ctx, IMAGE_CACHE_STATE, on_finish); } template @@ -97,13 +101,13 @@ void ImageCacheState::dump(ceph::Formatter *f) const { template ImageCacheState* ImageCacheState::create_image_cache_state( - I* image_ctx, int &r) { + I* image_ctx, plugin::Api& plugin_api, int &r) { std::string cache_state_str; ImageCacheState* cache_state = nullptr; ldout(image_ctx->cct, 20) << "image_cache_state:" << cache_state_str << dendl; r = 0; - bool dirty_cache = image_ctx->test_features(RBD_FEATURE_DIRTY_CACHE); + bool dirty_cache = plugin_api.test_image_features(image_ctx, RBD_FEATURE_DIRTY_CACHE); if (dirty_cache) { cls_client::metadata_get(&image_ctx->md_ctx, image_ctx->header_oid, IMAGE_CACHE_STATE, &cache_state_str); @@ -112,8 +116,8 @@ ImageCacheState* ImageCacheState::create_image_cache_state( bool pwl_enabled = cache::util::is_pwl_enabled(*image_ctx); bool cache_desired = pwl_enabled; cache_desired &= !image_ctx->read_only; - cache_desired &= !image_ctx->test_features(RBD_FEATURE_MIGRATING); - cache_desired &= !image_ctx->test_features(RBD_FEATURE_JOURNALING); + cache_desired &= !plugin_api.test_image_features(image_ctx, RBD_FEATURE_MIGRATING); + cache_desired &= !plugin_api.test_image_features(image_ctx, RBD_FEATURE_JOURNALING); cache_desired &= !image_ctx->old_format; if (!dirty_cache && !cache_desired) { @@ -123,7 +127,7 @@ ImageCacheState* ImageCacheState::create_image_cache_state( << dendl; r = -EINVAL; }else if ((!dirty_cache || cache_state_str.empty()) && cache_desired) { - cache_state = new ImageCacheState(image_ctx); + cache_state = new ImageCacheState(image_ctx, plugin_api); } else { ceph_assert(!cache_state_str.empty()); JSONFormattable f; @@ -141,9 +145,9 @@ ImageCacheState* ImageCacheState::create_image_cache_state( switch (cache_type) { case IMAGE_CACHE_TYPE_RWL: if (!cache_exists) { - cache_state = new ImageCacheState(image_ctx); + cache_state = new ImageCacheState(image_ctx, plugin_api); } else { - cache_state = new ImageCacheState(image_ctx, f); + cache_state = new ImageCacheState(image_ctx, f, plugin_api); } break; default: @@ -154,7 +158,8 @@ ImageCacheState* ImageCacheState::create_image_cache_state( } template -ImageCacheState* ImageCacheState::get_image_cache_state(I* image_ctx) { +ImageCacheState* ImageCacheState::get_image_cache_state( + I* image_ctx, plugin::Api& plugin_api) { ImageCacheState* cache_state = nullptr; string cache_state_str; cls_client::metadata_get(&image_ctx->md_ctx, image_ctx->header_oid, @@ -163,9 +168,9 @@ ImageCacheState* ImageCacheState::get_image_cache_state(I* image_ctx) { JSONFormattable f; bool success = get_json_format(cache_state_str, &f); if (!success) { - cache_state = new ImageCacheState(image_ctx); + cache_state = new ImageCacheState(image_ctx, plugin_api); } else { - cache_state = new ImageCacheState(image_ctx, f); + cache_state = new ImageCacheState(image_ctx, f, plugin_api); } } return cache_state; diff --git a/src/librbd/cache/pwl/ImageCacheState.h b/src/librbd/cache/pwl/ImageCacheState.h index 453316e866136..1da4306464f75 100644 --- a/src/librbd/cache/pwl/ImageCacheState.h +++ b/src/librbd/cache/pwl/ImageCacheState.h @@ -14,6 +14,9 @@ namespace ceph { } namespace librbd { + +namespace plugin { template struct Api; } + namespace cache { namespace pwl { @@ -21,6 +24,7 @@ template class ImageCacheState { private: ImageCtxT* m_image_ctx; + plugin::Api& m_plugin_api; public: bool present = false; bool empty = true; @@ -30,9 +34,10 @@ public: uint64_t size = 0; bool log_periodic_stats; - ImageCacheState(ImageCtxT* image_ctx); + ImageCacheState(ImageCtxT* image_ctx, plugin::Api& plugin_api); - ImageCacheState(ImageCtxT* image_ctx, JSONFormattable& f); + ImageCacheState(ImageCtxT* image_ctx, JSONFormattable& f, + plugin::Api& plugin_api); ~ImageCacheState() {} @@ -48,10 +53,10 @@ public: void dump(ceph::Formatter *f) const; static ImageCacheState* create_image_cache_state( - ImageCtxT* image_ctx, int &r); + ImageCtxT* image_ctx, plugin::Api& plugin_api, int &r); static ImageCacheState* get_image_cache_state( - ImageCtxT* image_ctx); + ImageCtxT* image_ctx, plugin::Api& plugin_api); bool is_valid(); }; diff --git a/src/librbd/cache/pwl/InitRequest.cc b/src/librbd/cache/pwl/InitRequest.cc index 5f3d87a4c3c5a..4b0962a81585e 100644 --- a/src/librbd/cache/pwl/InitRequest.cc +++ b/src/librbd/cache/pwl/InitRequest.cc @@ -8,19 +8,20 @@ #include "common/errno.h" #include "librbd/asio/ContextWQ.h" -#if defined(WITH_RBD_RWL) || defined(WITH_RBD_SSD_CACHE) #include "librbd/cache/pwl/ImageCacheState.h" #include "librbd/cache/WriteLogImageDispatch.h" -#endif // WITH_RBD_RWL || WITH_RBD_SSD_CACHE +#include "librbd/cache/ImageWriteback.h" #ifdef WITH_RBD_RWL #include "librbd/cache/pwl/ReplicatedWriteLog.h" #endif + #ifdef WITH_RBD_SSD_CACHE #include "librbd/cache/pwl/SSDWriteLog.h" #endif #include "librbd/cache/Utils.h" #include "librbd/ImageCtx.h" +#include "librbd/plugin/Api.h" #define dout_subsys ceph_subsys_rbd_pwl #undef dout_prefix @@ -35,35 +36,40 @@ using librbd::util::create_async_context_callback; using librbd::util::create_context_callback; template -InitRequest* InitRequest::create(I &image_ctx, - Context *on_finish) { - return new InitRequest(image_ctx, on_finish); +InitRequest* InitRequest::create( + I &image_ctx, + cache::ImageWritebackInterface& image_writeback, + plugin::Api& plugin_api, + Context *on_finish) { + return new InitRequest(image_ctx, image_writeback, plugin_api, on_finish); } template -InitRequest::InitRequest(I &image_ctx, Context *on_finish) +InitRequest::InitRequest( + I &image_ctx, + cache::ImageWritebackInterface& image_writeback, + plugin::Api& plugin_api, + Context *on_finish) : m_image_ctx(image_ctx), + m_image_writeback(image_writeback), + m_plugin_api(plugin_api), m_on_finish(create_async_context_callback(image_ctx, on_finish)), m_error_result(0) { } template void InitRequest::send() { -#if defined(WITH_RBD_RWL) || defined(WITH_RBD_SSD_CACHE) get_image_cache_state(); -#else - finish(); -#endif // WITH_RBD_RWL } -#if defined(WITH_RBD_RWL) || defined(WITH_RBD_SSD_CACHE) template void InitRequest::get_image_cache_state() { CephContext *cct = m_image_ctx.cct; ldout(cct, 10) << dendl; int r; - auto cache_state = ImageCacheState::create_image_cache_state(&m_image_ctx, r); + auto cache_state = ImageCacheState::create_image_cache_state( + &m_image_ctx, m_plugin_api, r); if (r < 0 || !cache_state) { save_result(r); @@ -85,14 +91,18 @@ void InitRequest::get_image_cache_state() { case cache::IMAGE_CACHE_TYPE_RWL: m_image_cache = new librbd::cache::pwl::ReplicatedWriteLog(m_image_ctx, - cache_state); + cache_state, + m_image_writeback, + m_plugin_api); break; #endif #ifdef WITH_RBD_SSD_CACHE case cache::IMAGE_CACHE_TYPE_SSD: m_image_cache = new librbd::cache::pwl::SSDWriteLog(m_image_ctx, - cache_state); + cache_state, + m_image_writeback, + m_plugin_api); break; #endif default: @@ -175,7 +185,8 @@ void InitRequest::handle_set_feature_bit(int r) { } // Register RWL dispatch - auto image_dispatch = new cache::WriteLogImageDispatch(&m_image_ctx, m_image_cache); + auto image_dispatch = new cache::WriteLogImageDispatch( + &m_image_ctx, m_image_cache, m_plugin_api); m_image_ctx.io_image_dispatcher->register_dispatch(image_dispatch); @@ -208,8 +219,6 @@ void InitRequest::handle_shutdown_image_cache(int r) { finish(); } -#endif // WITH_RBD_RWL - template void InitRequest::finish() { m_on_finish->complete(m_error_result); diff --git a/src/librbd/cache/pwl/InitRequest.h b/src/librbd/cache/pwl/InitRequest.h index b1bda3eda1cac..56e63425e341a 100644 --- a/src/librbd/cache/pwl/InitRequest.h +++ b/src/librbd/cache/pwl/InitRequest.h @@ -12,8 +12,12 @@ class ImageCtx; namespace io { class ImageDispatchInterface; } +namespace plugin { template struct Api; } + namespace cache { +class ImageWritebackInterface; + namespace pwl { template @@ -25,7 +29,11 @@ class ImageCacheState; template class InitRequest { public: - static InitRequest* create(ImageCtxT &image_ctx, Context *on_finish); + static InitRequest* create( + ImageCtxT &image_ctx, + librbd::cache::ImageWritebackInterface& image_writeback, + plugin::Api& plugin_api, + Context *on_finish); void send(); @@ -53,9 +61,14 @@ private: * @endverbatim */ - InitRequest(ImageCtxT &image_ctx, Context *on_finish); + InitRequest(ImageCtxT &image_ctx, + librbd::cache::ImageWritebackInterface& image_writeback, + plugin::Api& plugin_api, + Context *on_finish); ImageCtxT &m_image_ctx; + librbd::cache::ImageWritebackInterface& m_image_writeback; + plugin::Api& m_plugin_api; AbstractWriteLog *m_image_cache; Context *m_on_finish; diff --git a/src/librbd/cache/pwl/LogEntry.h b/src/librbd/cache/pwl/LogEntry.h index 0edd387f4de35..6f477fe83bdd0 100644 --- a/src/librbd/cache/pwl/LogEntry.h +++ b/src/librbd/cache/pwl/LogEntry.h @@ -157,12 +157,12 @@ public: WriteLogEntry(std::shared_ptr sync_point_entry, const uint64_t image_offset_bytes, const uint64_t write_bytes) : GenericWriteLogEntry(sync_point_entry, image_offset_bytes, write_bytes), - m_entry_bl_lock(ceph::make_mutex(util::unique_lock_name( + m_entry_bl_lock(ceph::make_mutex(pwl::unique_lock_name( "librbd::cache::pwl::WriteLogEntry::m_entry_bl_lock", this))) { } WriteLogEntry(const uint64_t image_offset_bytes, const uint64_t write_bytes) : GenericWriteLogEntry(nullptr, image_offset_bytes, write_bytes), - m_entry_bl_lock(ceph::make_mutex(util::unique_lock_name( + m_entry_bl_lock(ceph::make_mutex(pwl::unique_lock_name( "librbd::cache::pwl::WriteLogEntry::m_entry_bl_lock", this))) { } ~WriteLogEntry() override {}; diff --git a/src/librbd/cache/pwl/LogMap.cc b/src/librbd/cache/pwl/LogMap.cc index d05612ac4d31e..a2e6d65eb29ec 100644 --- a/src/librbd/cache/pwl/LogMap.cc +++ b/src/librbd/cache/pwl/LogMap.cc @@ -36,7 +36,7 @@ LogMapEntry::LogMapEntry(std::shared_ptr log_entry) template LogMap::LogMap(CephContext *cct) : m_cct(cct), - m_lock(ceph::make_mutex(util::unique_lock_name( + m_lock(ceph::make_mutex(pwl::unique_lock_name( "librbd::cache::pwl::LogMap::m_lock", this))) { } diff --git a/src/librbd/cache/pwl/LogOperation.cc b/src/librbd/cache/pwl/LogOperation.cc index 8125a5d41a720..aca964031e1c8 100644 --- a/src/librbd/cache/pwl/LogOperation.cc +++ b/src/librbd/cache/pwl/LogOperation.cc @@ -114,7 +114,7 @@ GenericWriteLogOperation::GenericWriteLogOperation(std::shared_ptr sy PerfCounters *perfcounter, CephContext *cct) : GenericLogOperation(dispatch_time, perfcounter), - m_lock(ceph::make_mutex(util::unique_lock_name( + m_lock(ceph::make_mutex(pwl::unique_lock_name( "librbd::cache::pwl::GenericWriteLogOperation::m_lock", this))), m_cct(cct), sync_point(sync_point) { diff --git a/src/librbd/cache/pwl/ReplicatedWriteLog.cc b/src/librbd/cache/pwl/ReplicatedWriteLog.cc index c7d1b4a6b5c8c..200746fccb2e5 100644 --- a/src/librbd/cache/pwl/ReplicatedWriteLog.cc +++ b/src/librbd/cache/pwl/ReplicatedWriteLog.cc @@ -16,6 +16,7 @@ #include "librbd/asio/ContextWQ.h" #include "librbd/cache/pwl/ImageCacheState.h" #include "librbd/cache/pwl/LogEntry.h" +#include "librbd/plugin/Api.h" #include #include @@ -35,8 +36,10 @@ const unsigned long int OPS_APPENDED_TOGETHER = MAX_ALLOC_PER_TRANSACTION; template ReplicatedWriteLog::ReplicatedWriteLog( - I &image_ctx, librbd::cache::pwl::ImageCacheState* cache_state) -: AbstractWriteLog(image_ctx, cache_state), + I &image_ctx, librbd::cache::pwl::ImageCacheState* cache_state, + ImageWritebackInterface& image_writeback, + plugin::Api& plugin_api) +: AbstractWriteLog(image_ctx, cache_state, image_writeback, plugin_api), m_pwl_pool_layout_name(POBJ_LAYOUT_NAME(rbd_pwl)) { } diff --git a/src/librbd/cache/pwl/ReplicatedWriteLog.h b/src/librbd/cache/pwl/ReplicatedWriteLog.h index 2464405de1aa8..bf4b0bea4e97b 100644 --- a/src/librbd/cache/pwl/ReplicatedWriteLog.h +++ b/src/librbd/cache/pwl/ReplicatedWriteLog.h @@ -34,7 +34,9 @@ template class ReplicatedWriteLog : public AbstractWriteLog { public: ReplicatedWriteLog( - ImageCtxT &image_ctx, librbd::cache::pwl::ImageCacheState* cache_state); + ImageCtxT &image_ctx, librbd::cache::pwl::ImageCacheState* cache_state, + ImageWritebackInterface& image_writeback, + plugin::Api& plugin_api); ~ReplicatedWriteLog(); ReplicatedWriteLog(const ReplicatedWriteLog&) = delete; ReplicatedWriteLog &operator=(const ReplicatedWriteLog&) = delete; diff --git a/src/librbd/cache/pwl/SSDWriteLog.cc b/src/librbd/cache/pwl/SSDWriteLog.cc index b34d1ce5f961c..34c1a53f57346 100644 --- a/src/librbd/cache/pwl/SSDWriteLog.cc +++ b/src/librbd/cache/pwl/SSDWriteLog.cc @@ -36,8 +36,10 @@ const unsigned long int ops_appended_together = MAX_WRITES_PER_SYNC_POINT; template SSDWriteLog::SSDWriteLog( - I &image_ctx, librbd::cache::pwl::ImageCacheState* cache_state) - : AbstractWriteLog(image_ctx, cache_state) + I &image_ctx, librbd::cache::pwl::ImageCacheState* cache_state, + cache::ImageWritebackInterface& image_writeback, + plugin::Api& plugin_api) + : AbstractWriteLog(image_ctx, cache_state, image_writeback, plugin_api) { } diff --git a/src/librbd/cache/pwl/SSDWriteLog.h b/src/librbd/cache/pwl/SSDWriteLog.h index 0052535273e06..ff9330e54610e 100644 --- a/src/librbd/cache/pwl/SSDWriteLog.h +++ b/src/librbd/cache/pwl/SSDWriteLog.h @@ -34,7 +34,9 @@ template class SSDWriteLog : public AbstractWriteLog { public: SSDWriteLog(ImageCtxT &image_ctx, - librbd::cache::pwl::ImageCacheState* cache_state); + librbd::cache::pwl::ImageCacheState* cache_state, + cache::ImageWritebackInterface& image_writeback, + plugin::Api& plugin_api); ~SSDWriteLog() {} SSDWriteLog(const SSDWriteLog&) = delete; SSDWriteLog &operator=(const SSDWriteLog&) = delete; diff --git a/src/librbd/cache/pwl/ShutdownRequest.cc b/src/librbd/cache/pwl/ShutdownRequest.cc index bb3c9520984e1..4475712dd6bb7 100644 --- a/src/librbd/cache/pwl/ShutdownRequest.cc +++ b/src/librbd/cache/pwl/ShutdownRequest.cc @@ -10,9 +10,8 @@ #include "librbd/asio/ContextWQ.h" #include "librbd/cache/Types.h" -#if defined(WITH_RBD_RWL) #include "librbd/cache/pwl/AbstractWriteLog.h" -#endif // WITH_RBD_RWL +#include "librbd/plugin/Api.h" #define dout_subsys ceph_subsys_rbd_pwl #undef dout_prefix @@ -30,31 +29,29 @@ template ShutdownRequest* ShutdownRequest::create( I &image_ctx, AbstractWriteLog *image_cache, + plugin::Api& plugin_api, Context *on_finish) { - return new ShutdownRequest(image_ctx, image_cache, on_finish); + return new ShutdownRequest(image_ctx, image_cache, plugin_api, on_finish); } template ShutdownRequest::ShutdownRequest( I &image_ctx, AbstractWriteLog *image_cache, + plugin::Api& plugin_api, Context *on_finish) : m_image_ctx(image_ctx), m_image_cache(image_cache), + m_plugin_api(plugin_api), m_on_finish(create_async_context_callback(image_ctx, on_finish)), m_error_result(0) { } template void ShutdownRequest::send() { -#if defined(WITH_RBD_RWL) send_shutdown_image_cache(); -#else - finish(); -#endif // WITH_RBD_RWL } -#if defined(WITH_RBD_RWL) template void ShutdownRequest::send_shutdown_image_cache() { CephContext *cct = m_image_ctx.cct; @@ -135,7 +132,7 @@ void ShutdownRequest::send_remove_image_cache_state() { Context *ctx = create_context_callback( this); std::shared_lock owner_lock{m_image_ctx.owner_lock}; - m_image_ctx.operations->execute_metadata_remove(IMAGE_CACHE_STATE, ctx); + m_plugin_api.execute_image_metadata_remove(&m_image_ctx, IMAGE_CACHE_STATE, ctx); } template @@ -151,8 +148,6 @@ void ShutdownRequest::handle_remove_image_cache_state(int r) { finish(); } -#endif // WITH_RBD_RWL - template void ShutdownRequest::finish() { m_on_finish->complete(m_error_result); diff --git a/src/librbd/cache/pwl/ShutdownRequest.h b/src/librbd/cache/pwl/ShutdownRequest.h index 2ed22f72782ca..dd2385b7ec889 100644 --- a/src/librbd/cache/pwl/ShutdownRequest.h +++ b/src/librbd/cache/pwl/ShutdownRequest.h @@ -10,6 +10,8 @@ namespace librbd { class ImageCtx; +namespace plugin { template struct Api; } + namespace cache { namespace pwl { @@ -26,6 +28,7 @@ public: static ShutdownRequest* create( ImageCtxT &image_ctx, AbstractWriteLog *image_cache, + plugin::Api& plugin_api, Context *on_finish); void send(); @@ -56,10 +59,12 @@ private: ShutdownRequest(ImageCtxT &image_ctx, AbstractWriteLog *image_cache, + plugin::Api& plugin_api, Context *on_finish); ImageCtxT &m_image_ctx; AbstractWriteLog *m_image_cache; + plugin::Api& m_plugin_api; Context *m_on_finish; int m_error_result; diff --git a/src/librbd/cache/pwl/Types.cc b/src/librbd/cache/pwl/Types.cc index 25c9dce130e19..9962d35df2961 100644 --- a/src/librbd/cache/pwl/Types.cc +++ b/src/librbd/cache/pwl/Types.cc @@ -5,6 +5,7 @@ #include "Types.h" #include "common/ceph_context.h" #include "include/Context.h" +#include "include/stringify.h" #define dout_subsys ceph_subsys_rbd_pwl #undef dout_prefix @@ -172,6 +173,10 @@ Context * override_ctx(int r, Context *ctx) { } } +std::string unique_lock_name(const std::string &name, void *address) { + return name + " (" + stringify(address) + ")"; +} + } // namespace pwl } // namespace cache } // namespace librbd diff --git a/src/librbd/cache/pwl/Types.h b/src/librbd/cache/pwl/Types.h index ab6c696a132de..4bb810b38f3ce 100644 --- a/src/librbd/cache/pwl/Types.h +++ b/src/librbd/cache/pwl/Types.h @@ -370,6 +370,8 @@ public: : io::Extent(extent), m_bl(bl) { } }; +std::string unique_lock_name(const std::string &name, void *address); + } // namespace pwl } // namespace cache } // namespace librbd diff --git a/src/librbd/exclusive_lock/PostAcquireRequest.cc b/src/librbd/exclusive_lock/PostAcquireRequest.cc index 51267c1cfcc67..4553b21583fa6 100644 --- a/src/librbd/exclusive_lock/PostAcquireRequest.cc +++ b/src/librbd/exclusive_lock/PostAcquireRequest.cc @@ -7,7 +7,6 @@ #include "common/dout.h" #include "common/errno.h" #include "include/stringify.h" -#include "librbd/cache/pwl/InitRequest.h" #include "librbd/ExclusiveLock.h" #include "librbd/ImageCtx.h" #include "librbd/ImageState.h" @@ -201,7 +200,7 @@ void PostAcquireRequest::handle_process_plugin_acquire_lock(int r) { return; } - send_open_image_cache(); + finish(); } template @@ -228,36 +227,6 @@ void PostAcquireRequest::handle_process_plugin_release_lock(int r) { send_close_journal(); } -template -void PostAcquireRequest::send_open_image_cache() { - CephContext *cct = m_image_ctx.cct; - ldout(cct, 10) << dendl; - - using klass = PostAcquireRequest; - Context *ctx = create_async_context_callback( - m_image_ctx, create_context_callback< - klass, &klass::handle_open_image_cache>(this)); - cache::pwl::InitRequest *req = cache::pwl::InitRequest::create( - m_image_ctx, ctx); - req->send(); -} - -template -void PostAcquireRequest::handle_open_image_cache(int r) { - CephContext *cct = m_image_ctx.cct; - ldout(cct, 10) << "r=" << r << dendl; - - save_result(r); - if (r < 0) { - lderr(cct) << "failed to open image cache: " << cpp_strerror(r) - << dendl; - send_process_plugin_release_lock(); - return; - } - - finish(); -} - template void PostAcquireRequest::send_close_journal() { if (m_journal == nullptr) { diff --git a/src/librbd/exclusive_lock/PostAcquireRequest.h b/src/librbd/exclusive_lock/PostAcquireRequest.h index 56532838bed19..2f7efdf076137 100644 --- a/src/librbd/exclusive_lock/PostAcquireRequest.h +++ b/src/librbd/exclusive_lock/PostAcquireRequest.h @@ -52,10 +52,6 @@ private: * PROCESS_PLUGIN_ACQUIRE* * | * * * | * * - * v * * - * OPEN_IMAGE_CACHE * - * | * * * - * | * * * * | v v v * | PROCESS_PLUGIN_RELEASE * | | @@ -108,9 +104,6 @@ private: void send_process_plugin_release_lock(); void handle_process_plugin_release_lock(int r); - void send_open_image_cache(); - void handle_open_image_cache(int r); - void apply(); void revert(); diff --git a/src/librbd/exclusive_lock/PreReleaseRequest.h b/src/librbd/exclusive_lock/PreReleaseRequest.h index 680cf3cb73fe5..4263379438e3e 100644 --- a/src/librbd/exclusive_lock/PreReleaseRequest.h +++ b/src/librbd/exclusive_lock/PreReleaseRequest.h @@ -106,9 +106,6 @@ private: void send_process_plugin_release_lock(); void handle_process_plugin_release_lock(int r); - void send_shut_down_image_cache(); - void handle_shut_down_image_cache(int r); - void send_invalidate_cache(); void handle_invalidate_cache(int r); diff --git a/src/librbd/internal.cc b/src/librbd/internal.cc index 1de2e14e9adbe..46dabacc89025 100644 --- a/src/librbd/internal.cc +++ b/src/librbd/internal.cc @@ -31,6 +31,7 @@ #include "librbd/Journal.h" #include "librbd/ObjectMap.h" #include "librbd/Operations.h" +#include "librbd/PluginRegistry.h" #include "librbd/Types.h" #include "librbd/Utils.h" #include "librbd/api/Config.h" @@ -1629,7 +1630,7 @@ int validate_pool(IoCtx &io_ctx, CephContext *cct) { !ictx->exclusive_lock->is_lock_owner()) && ictx->test_features(RBD_FEATURE_DIRTY_CACHE)) { C_SaferCond ctx3; - librbd::cache::util::discard_cache<>(*ictx, &ctx3); + ictx->plugin_registry->discard(&ctx3); r = ctx3.wait(); } return r; diff --git a/src/librbd/plugin/Api.cc b/src/librbd/plugin/Api.cc index 76a9859f79dd5..67303be3f4e65 100644 --- a/src/librbd/plugin/Api.cc +++ b/src/librbd/plugin/Api.cc @@ -1,9 +1,13 @@ // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*- // vim: ts=8 sw=2 smarttab +#include "common/Timer.h" #include "librbd/plugin/Api.h" #include "librbd/ImageCtx.h" +#include "librbd/io/AioCompletion.h" #include "librbd/io/Utils.h" +#include "librbd/Operations.h" +#include "librbd/Utils.h" namespace librbd { namespace plugin { @@ -17,6 +21,71 @@ void Api::read_parent( on_finish); } +template +void Api::execute_image_metadata_set( + I *image_ctx, const std::string &key, + const std::string &value, Context *on_finish) { + ImageCtx* ictx = util::get_image_ctx(image_ctx); + ictx->operations->execute_metadata_set(key, value, on_finish); +} + +template +void Api::execute_image_metadata_remove( + I *image_ctx, const std::string &key, Context *on_finish) { + ImageCtx* ictx = util::get_image_ctx(image_ctx); + ictx->operations->execute_metadata_remove(key, on_finish); +} + +template +void Api::get_image_timer_instance( + CephContext *cct, SafeTimer **timer, ceph::mutex **timer_lock) { + ImageCtx::get_timer_instance(cct, timer, timer_lock); +} + +template +bool Api::test_image_features(I *image_ctx, uint64_t features) { + return image_ctx->test_features(features); +} + +template +void Api::update_aio_comp(io::AioCompletion* aio_comp, + uint32_t request_count, + io::ReadResult &read_result, + io::Extents &image_extents) { + aio_comp->set_request_count(request_count); + aio_comp->read_result = std::move(read_result); + aio_comp->read_result.set_image_extents(image_extents); + start_in_flight_io(aio_comp); +} + +template +void Api::update_aio_comp( + io::AioCompletion* aio_comp, uint32_t request_count) { + aio_comp->set_request_count(request_count); + start_in_flight_io(aio_comp); +} + +template +io::ReadResult::C_ImageReadRequest* Api::create_image_read_request( + io::AioCompletion* aio_comp, uint64_t buffer_offset, + const Extents& image_extents) { + return new io::ReadResult::C_ImageReadRequest( + aio_comp, buffer_offset, image_extents); +} + +template +io::C_AioRequest* Api::create_aio_request(io::AioCompletion* aio_comp) { + io::C_AioRequest *req_comp = new io::C_AioRequest(aio_comp); + return req_comp; +} + +template +void Api::start_in_flight_io(io::AioCompletion* aio_comp) { + if (!aio_comp->async_op.started()) { + aio_comp->start_op(); + } +} + } // namespace plugin } // namespace librbd diff --git a/src/librbd/plugin/Api.h b/src/librbd/plugin/Api.h index f2dd5c8224915..2d55c17c19fe0 100644 --- a/src/librbd/plugin/Api.h +++ b/src/librbd/plugin/Api.h @@ -4,15 +4,24 @@ #ifndef CEPH_LIBRBD_PLUGIN_API_H #define CEPH_LIBRBD_PLUGIN_API_H +#include "common/ceph_mutex.h" #include "include/common_fwd.h" #include "include/int_types.h" #include "include/rados/librados.hpp" #include "librbd/io/Types.h" +#include "librbd/io/ReadResult.h" namespace ZTracer { struct Trace; } +class SafeTimer; + namespace librbd { +namespace io { +class AioCompletion; +class C_AioRequest; +} + struct ImageCtx; namespace plugin { @@ -29,6 +38,43 @@ struct Api { librados::snap_t snap_id, const ZTracer::Trace &trace, Context* on_finish); + virtual void execute_image_metadata_set( + ImageCtxT *image_ctx, + const std::string &key, + const std::string &value, + Context *on_finish); + + virtual void execute_image_metadata_remove( + ImageCtxT *image_ctx, + const std::string &key, + Context *on_finish); + + virtual void get_image_timer_instance( + CephContext *cct, SafeTimer **timer, + ceph::mutex **timer_lock); + + virtual bool test_image_features( + ImageCtxT *image_ctx, + uint64_t features); + + virtual void update_aio_comp( + io::AioCompletion* aio_comp, + uint32_t request_count, + io::ReadResult& read_result, + io::Extents &image_extents); + + virtual void update_aio_comp( + io::AioCompletion* aio_comp, + uint32_t request_count); + + virtual io::ReadResult::C_ImageReadRequest* create_image_read_request( + io::AioCompletion* aio_comp, uint64_t buffer_offset, + const Extents& image_extents); + + virtual io::C_AioRequest* create_aio_request(io::AioCompletion* aio_comp); + +private: + void start_in_flight_io(io::AioCompletion* aio_comp); }; } // namespace plugin diff --git a/src/librbd/plugin/WriteLogImageCache.cc b/src/librbd/plugin/WriteLogImageCache.cc new file mode 100644 index 0000000000000..2a32841f4b423 --- /dev/null +++ b/src/librbd/plugin/WriteLogImageCache.cc @@ -0,0 +1,104 @@ +// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*- +// vim: ts=8 sw=2 smarttab + +#include "ceph_ver.h" +#include "common/dout.h" +#include "common/errno.h" +#include "common/PluginRegistry.h" +#include "librbd/ImageCtx.h" +#include "librbd/cache/WriteLogImageDispatch.h" +#include "librbd/cache/ImageWriteback.h" +#include "librbd/cache/pwl/DiscardRequest.h" +#include "librbd/cache/pwl/InitRequest.h" +#include "librbd/io/ImageDispatcherInterface.h" +#include "librbd/plugin/WriteLogImageCache.h" + +extern "C" { + +const char *__ceph_plugin_version() { + return CEPH_GIT_NICE_VER; +} + +int __ceph_plugin_init(CephContext *cct, const std::string& type, + const std::string& name) { + auto plugin_registry = cct->get_plugin_registry(); + return plugin_registry->add( + type, name, new librbd::plugin::WriteLogImageCache(cct)); +} + +} // extern "C" + +#define dout_subsys ceph_subsys_rbd +#undef dout_prefix +#define dout_prefix *_dout << "librbd::plugin::WriteLogImageCache: " \ + << this << " " << __func__ << ": " + +namespace librbd { +namespace plugin { + +template +void WriteLogImageCache::init(I* image_ctx, Api& api, + cache::ImageWritebackInterface& image_writeback, + PluginHookPoints& hook_points_list, + Context* on_finish) { + bool rwl_enabled = image_ctx->config.template get_val( + "rbd_rwl_enabled"); + if (!rwl_enabled || !image_ctx->data_ctx.is_valid()) { + on_finish->complete(0); + return; + } + + auto cct = image_ctx->cct; + ldout(cct, 5) << dendl; + + auto hook_points = std::make_unique( + image_ctx, image_writeback, api); + hook_points_list.emplace_back(std::move(hook_points)); + + on_finish->complete(0); +} + +template +WriteLogImageCache::~WriteLogImageCache() { +} + +template +WriteLogImageCache::HookPoints::HookPoints( + I* image_ctx, cache::ImageWritebackInterface& image_writeback, + plugin::Api& plugin_api) + : m_image_ctx(image_ctx), m_image_writeback(image_writeback), + m_plugin_api(plugin_api) +{ +} + +template +WriteLogImageCache::HookPoints::~HookPoints() { +} + +template +void WriteLogImageCache::HookPoints::acquired_exclusive_lock( + Context* on_finish) { + cache::pwl::InitRequest *req = cache::pwl::InitRequest::create( + *m_image_ctx, m_image_writeback, m_plugin_api, on_finish); + req->send(); +} + +template +void WriteLogImageCache::HookPoints::prerelease_exclusive_lock( + Context* on_finish) { + m_image_ctx->io_image_dispatcher->shut_down_dispatch( + io::IMAGE_DISPATCH_LAYER_WRITEBACK_CACHE, on_finish); +} + +template +void WriteLogImageCache::HookPoints::discard( + Context* on_finish) { + cache::pwl::DiscardRequest *req = cache::pwl::DiscardRequest::create( + *m_image_ctx, m_plugin_api, on_finish); + req->send(); +} + +} // namespace plugin +} // namespace librbd + +template class librbd::plugin::WriteLogImageCache; diff --git a/src/librbd/plugin/WriteLogImageCache.h b/src/librbd/plugin/WriteLogImageCache.h new file mode 100644 index 0000000000000..2ceb87ec654de --- /dev/null +++ b/src/librbd/plugin/WriteLogImageCache.h @@ -0,0 +1,53 @@ +// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*- +// vim: ts=8 sw=2 smarttab + +#ifndef CEPH_LIBRBD_PLUGIN_WRITELOG_IMAGE_CACHE_H +#define CEPH_LIBRBD_PLUGIN_WRITELOG_IMAGE_CACHE_H + +#include "librbd/plugin/Types.h" +#include "include/Context.h" + +namespace librbd { + +struct ImageCtx; + +namespace plugin { + +template +class WriteLogImageCache : public Interface { +public: + WriteLogImageCache(CephContext* cct) : Interface(cct) { + } + + ~WriteLogImageCache() override; + + void init(ImageCtxT* image_ctx, Api& api, + cache::ImageWritebackInterface& image_writeback, + PluginHookPoints& hook_points_list, + Context* on_finish) override; + + class HookPoints : public plugin::HookPoints { + public: + HookPoints(ImageCtxT* image_ctx, + cache::ImageWritebackInterface& image_writeback, + plugin::Api& plugin_api); + ~HookPoints() override; + + void acquired_exclusive_lock(Context* on_finish) override; + void prerelease_exclusive_lock(Context* on_finish) override; + void discard(Context* on_finish) override; + + private: + ImageCtxT* m_image_ctx; + cache::ImageWritebackInterface& m_image_writeback; + plugin::Api& m_plugin_api; + }; + +}; + +} // namespace plugin +} // namespace librbd + +extern template class librbd::plugin::WriteLogImageCache; + +#endif // CEPH_LIBRBD_PLUGIN_WRITELOG_IMAGE_CACHE_H diff --git a/src/test/librbd/CMakeLists.txt b/src/test/librbd/CMakeLists.txt index 45039108b75f6..63d87af72d096 100644 --- a/src/test/librbd/CMakeLists.txt +++ b/src/test/librbd/CMakeLists.txt @@ -167,6 +167,11 @@ target_link_libraries(unittest_librbd OpenSSL::SSL ${UNITTEST_LIBS}) +if(WITH_RBD_RWL OR WITH_RBD_SSD_CACHE) + target_link_libraries(unittest_librbd + librbd_plugin_pwl_cache) +endif() + add_executable(ceph_test_librbd test_main.cc $) diff --git a/src/test/librbd/cache/pwl/test_mock_ReplicatedWriteLog.cc b/src/test/librbd/cache/pwl/test_mock_ReplicatedWriteLog.cc index d1622a2ce34a6..5160b189d630c 100644 --- a/src/test/librbd/cache/pwl/test_mock_ReplicatedWriteLog.cc +++ b/src/test/librbd/cache/pwl/test_mock_ReplicatedWriteLog.cc @@ -7,10 +7,10 @@ #include "test/librbd/test_support.h" #include "test/librbd/mock/MockImageCtx.h" #include "include/rbd/librbd.hpp" -#include "librbd/cache/pwl/AbstractWriteLog.h" #include "librbd/cache/pwl/ImageCacheState.h" #include "librbd/cache/pwl/Types.h" #include "librbd/cache/ImageWriteback.h" +#include "librbd/plugin/Api.h" namespace librbd { namespace { @@ -37,11 +37,13 @@ inline ImageCtx *get_image_ctx(MockImageCtx *image_ctx) { #include "librbd/cache/pwl/AbstractWriteLog.cc" #include "librbd/cache/pwl/ReplicatedWriteLog.cc" +template class librbd::cache::pwl::ReplicatedWriteLog; // template definitions #include "librbd/cache/ImageWriteback.cc" #include "librbd/cache/pwl/ImageCacheState.cc" #include "librbd/cache/pwl/Request.cc" +#include "librbd/plugin/Api.cc" namespace librbd { namespace cache { @@ -52,12 +54,18 @@ using ::testing::DoDefault; using ::testing::InSequence; using ::testing::Invoke; +typedef io::Extent Extent; +typedef io::Extents Extents; + struct TestMockCacheReplicatedWriteLog : public TestMockFixture { typedef librbd::cache::pwl::ReplicatedWriteLog MockReplicatedWriteLog; typedef librbd::cache::pwl::ImageCacheState MockImageCacheStateRWL; + typedef librbd::cache::ImageWriteback MockImageWriteback; + typedef librbd::plugin::Api MockApi; - MockImageCacheStateRWL *get_cache_state(MockImageCtx& mock_image_ctx) { - MockImageCacheStateRWL *rwl_state = new MockImageCacheStateRWL(&mock_image_ctx); + MockImageCacheStateRWL *get_cache_state( + MockImageCtx& mock_image_ctx, MockApi& mock_api) { + MockImageCacheStateRWL *rwl_state = new MockImageCacheStateRWL(&mock_image_ctx, mock_api); return rwl_state; } @@ -112,7 +120,8 @@ TEST_F(TestMockCacheReplicatedWriteLog, init_state_write) { ASSERT_EQ(0, open_image(m_image_name, &ictx)); MockImageCtx mock_image_ctx(*ictx); - MockImageCacheStateRWL image_cache_state(&mock_image_ctx); + MockApi mock_api; + MockImageCacheStateRWL image_cache_state(&mock_image_ctx, mock_api); validate_cache_state(ictx, image_cache_state, false, true, true, "", "", 0); @@ -152,7 +161,8 @@ TEST_F(TestMockCacheReplicatedWriteLog, init_state_json_write) { \"pwl_path\": \"/tmp\", \ \"pwl_size\": \"1024\" }"; get_jf(strf, &f); - MockImageCacheStateRWL image_cache_state(&mock_image_ctx, f); + MockApi mock_api; + MockImageCacheStateRWL image_cache_state(&mock_image_ctx, f, mock_api); validate_cache_state(ictx, image_cache_state, true, false, false, "testhost", "/tmp", 1024); @@ -169,7 +179,11 @@ TEST_F(TestMockCacheReplicatedWriteLog, init_shutdown) { ASSERT_EQ(0, open_image(m_image_name, &ictx)); MockImageCtx mock_image_ctx(*ictx); - MockReplicatedWriteLog rwl(mock_image_ctx, get_cache_state(mock_image_ctx)); + MockImageWriteback mock_image_writeback(mock_image_ctx); + MockApi mock_api; + MockReplicatedWriteLog rwl( + mock_image_ctx, get_cache_state(mock_image_ctx, mock_api), + mock_image_writeback, mock_api); MockContextRWL finish_ctx1; expect_op_work_queue(mock_image_ctx); expect_metadata_set(mock_image_ctx); @@ -189,7 +203,11 @@ TEST_F(TestMockCacheReplicatedWriteLog, write) { ASSERT_EQ(0, open_image(m_image_name, &ictx)); MockImageCtx mock_image_ctx(*ictx); - MockReplicatedWriteLog rwl(mock_image_ctx, get_cache_state(mock_image_ctx)); + MockImageWriteback mock_image_writeback(mock_image_ctx); + MockApi mock_api; + MockReplicatedWriteLog rwl( + mock_image_ctx, get_cache_state(mock_image_ctx, mock_api), + mock_image_writeback, mock_api); MockContextRWL finish_ctx1; expect_op_work_queue(mock_image_ctx); @@ -218,7 +236,12 @@ TEST_F(TestMockCacheReplicatedWriteLog, flush) { ASSERT_EQ(0, open_image(m_image_name, &ictx)); MockImageCtx mock_image_ctx(*ictx); - MockReplicatedWriteLog rwl(mock_image_ctx, get_cache_state(mock_image_ctx)); + MockImageWriteback mock_image_writeback(mock_image_ctx); + MockApi mock_api; + MockReplicatedWriteLog rwl( + mock_image_ctx, get_cache_state(mock_image_ctx, mock_api), + mock_image_writeback, mock_api); + expect_op_work_queue(mock_image_ctx); expect_metadata_set(mock_image_ctx); @@ -254,7 +277,12 @@ TEST_F(TestMockCacheReplicatedWriteLog, flush_source_shutdown) { ASSERT_EQ(0, open_image(m_image_name, &ictx)); MockImageCtx mock_image_ctx(*ictx); - MockReplicatedWriteLog rwl(mock_image_ctx, get_cache_state(mock_image_ctx)); + MockImageWriteback mock_image_writeback(mock_image_ctx); + MockApi mock_api; + MockReplicatedWriteLog rwl( + mock_image_ctx, get_cache_state(mock_image_ctx, mock_api), + mock_image_writeback, mock_api); + expect_op_work_queue(mock_image_ctx); expect_metadata_set(mock_image_ctx); @@ -288,7 +316,12 @@ TEST_F(TestMockCacheReplicatedWriteLog, flush_source_internal) { ASSERT_EQ(0, open_image(m_image_name, &ictx)); MockImageCtx mock_image_ctx(*ictx); - MockReplicatedWriteLog rwl(mock_image_ctx, get_cache_state(mock_image_ctx)); + MockImageWriteback mock_image_writeback(mock_image_ctx); + MockApi mock_api; + MockReplicatedWriteLog rwl( + mock_image_ctx, get_cache_state(mock_image_ctx, mock_api), + mock_image_writeback, mock_api); + expect_op_work_queue(mock_image_ctx); expect_metadata_set(mock_image_ctx); @@ -322,7 +355,11 @@ TEST_F(TestMockCacheReplicatedWriteLog, flush_source_user) { ASSERT_EQ(0, open_image(m_image_name, &ictx)); MockImageCtx mock_image_ctx(*ictx); - MockReplicatedWriteLog rwl(mock_image_ctx, get_cache_state(mock_image_ctx)); + MockImageWriteback mock_image_writeback(mock_image_ctx); + MockApi mock_api; + MockReplicatedWriteLog rwl( + mock_image_ctx, get_cache_state(mock_image_ctx, mock_api), + mock_image_writeback, mock_api); expect_op_work_queue(mock_image_ctx); expect_metadata_set(mock_image_ctx); @@ -357,7 +394,11 @@ TEST_F(TestMockCacheReplicatedWriteLog, read_hit_rwl_cache) { ASSERT_EQ(0, open_image(m_image_name, &ictx)); MockImageCtx mock_image_ctx(*ictx); - MockReplicatedWriteLog rwl(mock_image_ctx, get_cache_state(mock_image_ctx)); + MockImageWriteback mock_image_writeback(mock_image_ctx); + MockApi mock_api; + MockReplicatedWriteLog rwl( + mock_image_ctx, get_cache_state(mock_image_ctx, mock_api), + mock_image_writeback, mock_api); expect_op_work_queue(mock_image_ctx); expect_metadata_set(mock_image_ctx); @@ -396,7 +437,11 @@ TEST_F(TestMockCacheReplicatedWriteLog, read_hit_part_rwl_cache) { ASSERT_EQ(0, open_image(m_image_name, &ictx)); MockImageCtx mock_image_ctx(*ictx); - MockReplicatedWriteLog rwl(mock_image_ctx, get_cache_state(mock_image_ctx)); + MockImageWriteback mock_image_writeback(mock_image_ctx); + MockApi mock_api; + MockReplicatedWriteLog rwl( + mock_image_ctx, get_cache_state(mock_image_ctx, mock_api), + mock_image_writeback, mock_api); expect_op_work_queue(mock_image_ctx); expect_metadata_set(mock_image_ctx); @@ -439,7 +484,11 @@ TEST_F(TestMockCacheReplicatedWriteLog, read_miss_rwl_cache) { ASSERT_EQ(0, open_image(m_image_name, &ictx)); MockImageCtx mock_image_ctx(*ictx); - MockReplicatedWriteLog rwl(mock_image_ctx, get_cache_state(mock_image_ctx)); + MockImageWriteback mock_image_writeback(mock_image_ctx); + MockApi mock_api; + MockReplicatedWriteLog rwl( + mock_image_ctx, get_cache_state(mock_image_ctx, mock_api), + mock_image_writeback, mock_api); expect_op_work_queue(mock_image_ctx); expect_metadata_set(mock_image_ctx); @@ -477,7 +526,11 @@ TEST_F(TestMockCacheReplicatedWriteLog, discard) { ASSERT_EQ(0, open_image(m_image_name, &ictx)); MockImageCtx mock_image_ctx(*ictx); - MockReplicatedWriteLog rwl(mock_image_ctx, get_cache_state(mock_image_ctx)); + MockImageWriteback mock_image_writeback(mock_image_ctx); + MockApi mock_api; + MockReplicatedWriteLog rwl( + mock_image_ctx, get_cache_state(mock_image_ctx, mock_api), + mock_image_writeback, mock_api); expect_op_work_queue(mock_image_ctx); expect_metadata_set(mock_image_ctx); @@ -521,7 +574,11 @@ TEST_F(TestMockCacheReplicatedWriteLog, writesame) { ASSERT_EQ(0, open_image(m_image_name, &ictx)); MockImageCtx mock_image_ctx(*ictx); - MockReplicatedWriteLog rwl(mock_image_ctx, get_cache_state(mock_image_ctx)); + MockImageWriteback mock_image_writeback(mock_image_ctx); + MockApi mock_api; + MockReplicatedWriteLog rwl( + mock_image_ctx, get_cache_state(mock_image_ctx, mock_api), + mock_image_writeback, mock_api); expect_op_work_queue(mock_image_ctx); expect_metadata_set(mock_image_ctx); @@ -559,7 +616,11 @@ TEST_F(TestMockCacheReplicatedWriteLog, invalidate) { ASSERT_EQ(0, open_image(m_image_name, &ictx)); MockImageCtx mock_image_ctx(*ictx); - MockReplicatedWriteLog rwl(mock_image_ctx, get_cache_state(mock_image_ctx)); + MockImageWriteback mock_image_writeback(mock_image_ctx); + MockApi mock_api; + MockReplicatedWriteLog rwl( + mock_image_ctx, get_cache_state(mock_image_ctx, mock_api), + mock_image_writeback, mock_api); expect_op_work_queue(mock_image_ctx); expect_metadata_set(mock_image_ctx); @@ -595,7 +656,11 @@ TEST_F(TestMockCacheReplicatedWriteLog, compare_and_write_compare_matched) { ASSERT_EQ(0, open_image(m_image_name, &ictx)); MockImageCtx mock_image_ctx(*ictx); - MockReplicatedWriteLog rwl(mock_image_ctx, get_cache_state(mock_image_ctx)); + MockImageWriteback mock_image_writeback(mock_image_ctx); + MockApi mock_api; + MockReplicatedWriteLog rwl( + mock_image_ctx, get_cache_state(mock_image_ctx, mock_api), + mock_image_writeback, mock_api); expect_op_work_queue(mock_image_ctx); expect_metadata_set(mock_image_ctx); @@ -645,7 +710,11 @@ TEST_F(TestMockCacheReplicatedWriteLog, compare_and_write_compare_failed) { ASSERT_EQ(0, open_image(m_image_name, &ictx)); MockImageCtx mock_image_ctx(*ictx); - MockReplicatedWriteLog rwl(mock_image_ctx, get_cache_state(mock_image_ctx)); + MockImageWriteback mock_image_writeback(mock_image_ctx); + MockApi mock_api; + MockReplicatedWriteLog rwl( + mock_image_ctx, get_cache_state(mock_image_ctx, mock_api), + mock_image_writeback, mock_api); expect_op_work_queue(mock_image_ctx); expect_metadata_set(mock_image_ctx); diff --git a/src/test/librbd/exclusive_lock/test_mock_PostAcquireRequest.cc b/src/test/librbd/exclusive_lock/test_mock_PostAcquireRequest.cc index 0cb959d19140b..943b8cc2dfaeb 100644 --- a/src/test/librbd/exclusive_lock/test_mock_PostAcquireRequest.cc +++ b/src/test/librbd/exclusive_lock/test_mock_PostAcquireRequest.cc @@ -11,7 +11,6 @@ #include "test/librbd/mock/MockObjectMap.h" #include "test/librados_test_stub/MockTestMemIoCtxImpl.h" #include "test/librados_test_stub/MockTestMemRadosClient.h" -#include "librbd/cache/pwl/InitRequest.h" #include "librbd/exclusive_lock/PostAcquireRequest.h" #include "librbd/image/RefreshRequest.h" @@ -60,32 +59,6 @@ struct RefreshRequest { RefreshRequest *RefreshRequest::s_instance = nullptr; } // namespace image - -namespace cache { -namespace pwl { - -template<> -struct InitRequest { - static InitRequest *s_instance; - Context *on_finish = nullptr; - - static InitRequest *create(librbd::MockTestImageCtx &image_ctx, - Context *on_finish) { - ceph_assert(s_instance != nullptr); - s_instance->on_finish = on_finish; - return s_instance; - } - - InitRequest() { - s_instance = this; - } - MOCK_METHOD0(send, void()); -}; - -InitRequest *InitRequest::s_instance = nullptr; - -} // namespace pwl -} // namespace cache } // namespace librbd // template definitions @@ -117,7 +90,6 @@ class TestMockExclusiveLockPostAcquireRequest : public TestMockFixture { public: typedef PostAcquireRequest MockPostAcquireRequest; typedef librbd::image::RefreshRequest MockRefreshRequest; - typedef librbd::cache::pwl::InitRequest MockInitRequest; void expect_test_features(MockTestImageCtx &mock_image_ctx, uint64_t features, bool enabled) { @@ -245,8 +217,6 @@ TEST_F(TestMockExclusiveLockPostAcquireRequest, Success) { expect_acquired_exclusive_lock(mock_image_ctx, 0); - MockInitRequest mock_init_request; - expect_init_image_cache(mock_image_ctx, mock_init_request, 0); C_SaferCond acquire_ctx; C_SaferCond ctx; MockPostAcquireRequest *req = MockPostAcquireRequest::create(mock_image_ctx, @@ -279,9 +249,6 @@ TEST_F(TestMockExclusiveLockPostAcquireRequest, SuccessRefresh) { expect_acquired_exclusive_lock(mock_image_ctx, 0); - MockInitRequest mock_init_request; - expect_init_image_cache(mock_image_ctx, mock_init_request, 0); - C_SaferCond acquire_ctx; C_SaferCond ctx; MockPostAcquireRequest *req = MockPostAcquireRequest::create(mock_image_ctx, @@ -315,9 +282,6 @@ TEST_F(TestMockExclusiveLockPostAcquireRequest, SuccessJournalDisabled) { expect_acquired_exclusive_lock(mock_image_ctx, 0); - MockInitRequest mock_init_request; - expect_init_image_cache(mock_image_ctx, mock_init_request, 0); - C_SaferCond acquire_ctx; C_SaferCond ctx; MockPostAcquireRequest *req = MockPostAcquireRequest::create(mock_image_ctx, @@ -356,9 +320,6 @@ TEST_F(TestMockExclusiveLockPostAcquireRequest, SuccessObjectMapDisabled) { expect_acquired_exclusive_lock(mock_image_ctx, 0); - MockInitRequest mock_init_request; - expect_init_image_cache(mock_image_ctx, mock_init_request, 0); - C_SaferCond acquire_ctx; C_SaferCond ctx; MockPostAcquireRequest *req = MockPostAcquireRequest::create(mock_image_ctx, @@ -415,9 +376,6 @@ TEST_F(TestMockExclusiveLockPostAcquireRequest, RefreshLockDisabled) { expect_acquired_exclusive_lock(mock_image_ctx, 0); - MockInitRequest mock_init_request; - expect_init_image_cache(mock_image_ctx, mock_init_request, 0); - C_SaferCond acquire_ctx; C_SaferCond ctx; MockPostAcquireRequest *req = MockPostAcquireRequest::create(mock_image_ctx, @@ -538,9 +496,6 @@ TEST_F(TestMockExclusiveLockPostAcquireRequest, InitImageCacheError) { expect_acquired_exclusive_lock(mock_image_ctx, -ENOENT); expect_prerelease_exclusive_lock(mock_image_ctx, 0); - MockInitRequest mock_init_request; - expect_init_image_cache(mock_image_ctx, mock_init_request, -ENOENT); - expect_close_journal(mock_image_ctx, mock_journal); expect_close_object_map(mock_image_ctx, mock_object_map); @@ -612,9 +567,6 @@ TEST_F(TestMockExclusiveLockPostAcquireRequest, OpenObjectMapTooBig) { expect_acquired_exclusive_lock(mock_image_ctx, 0); - MockInitRequest mock_init_request; - expect_init_image_cache(mock_image_ctx, mock_init_request, 0); - C_SaferCond acquire_ctx; C_SaferCond ctx; MockPostAcquireRequest *req = MockPostAcquireRequest::create(mock_image_ctx,