From: shangdehao1 Date: Wed, 22 May 2019 23:01:12 +0000 (+0800) Subject: librbd: cleanup RO cache X-Git-Tag: v15.1.0~2379^2~16 X-Git-Url: http://git-server-git.apps.pok.os.sepia.ceph.com/?a=commitdiff_plain;h=ab1c146ad6d937662098088ea4ac3ba116dd4130;p=ceph.git librbd: cleanup RO cache - cleanup invalid comments - cleanup useless method and data member - fix spelling mistake - change naming from SharedReadOnlyCache to ParentCache - change file name from SharedReadOnlyObjectDispatch to ParentCacheObjectDispath Signed-off-by: Dehao Shang --- diff --git a/src/librbd/CMakeLists.txt b/src/librbd/CMakeLists.txt index 4150ef604d81..ca82d11b0f75 100644 --- a/src/librbd/CMakeLists.txt +++ b/src/librbd/CMakeLists.txt @@ -36,7 +36,7 @@ set(librbd_internal_srcs api/Trash.cc cache/ImageWriteback.cc cache/ObjectCacherObjectDispatch.cc - cache/SharedReadOnlyObjectDispatch.cc + cache/ParentCacheObjectDispatch.cc cache/SharedPersistentObjectCacher.cc cache/ObjectCacherWriteback.cc cache/PassthroughImageCache.cc diff --git a/src/librbd/cache/ParentCacheObjectDispatch.cc b/src/librbd/cache/ParentCacheObjectDispatch.cc new file mode 100644 index 000000000000..251e8b5505e0 --- /dev/null +++ b/src/librbd/cache/ParentCacheObjectDispatch.cc @@ -0,0 +1,160 @@ +// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*- +// vim: ts=8 sw=2 smarttab + +#include "common/WorkQueue.h" +#include "librbd/ImageCtx.h" +#include "librbd/Journal.h" +#include "librbd/Utils.h" +#include "librbd/io/ObjectDispatchSpec.h" +#include "librbd/io/ObjectDispatcher.h" +#include "librbd/io/Utils.h" +#include "librbd/cache/ParentCacheObjectDispatch.h" +#include "osd/osd_types.h" +#include "osdc/WritebackHandler.h" + +#include + +#define dout_subsys ceph_subsys_rbd +#undef dout_prefix +#define dout_prefix *_dout << "librbd::cache::ParentCacheObjectDispatch: " \ + << this << " " << __func__ << ": " + +namespace librbd { +namespace cache { + +template +ParentCacheObjectDispatch::ParentCacheObjectDispatch( + I* image_ctx) : m_image_ctx(image_ctx), m_cache_client(nullptr), + m_initialized(false), m_object_store(nullptr) { +} + +template +ParentCacheObjectDispatch::~ParentCacheObjectDispatch() { + delete m_object_store; + delete m_cache_client; +} + +// TODO if connect fails, init will return error to high layer. +template +void ParentCacheObjectDispatch::init() { + auto cct = m_image_ctx->cct; + ldout(cct, 5) << dendl; + + if (m_image_ctx->parent != nullptr) { + ldout(cct, 5) << "child image: skipping" << dendl; + return; + } + + ldout(cct, 5) << "parent image: setup SRO cache client" << dendl; + + std::string controller_path = ((CephContext*)cct)->_conf.get_val("immutable_object_cache_sock"); + if(m_cache_client == nullptr) { + m_cache_client = new C(controller_path.c_str(), m_image_ctx->cct); + } + m_cache_client->run(); + + int ret = m_cache_client->connect(); + if (ret < 0) { + ldout(cct, 5) << "SRO cache client fail to connect with local controller: " + << "please start ceph-immutable-object-cache daemon" + << dendl; + } else { + ldout(cct, 5) << "SRO cache client to register volume " + << "name = " << m_image_ctx->id + << " on ceph-immutable-object-cache daemon" + << dendl; + + auto ctx = new FunctionContext([this](bool reg) { + handle_register_client(reg); + }); + + ret = m_cache_client->register_client(ctx); + + if (ret >= 0) { + // add ourself to the IO object dispatcher chain + m_image_ctx->io_object_dispatcher->register_object_dispatch(this); + m_initialized = true; + } + } +} + +template +bool ParentCacheObjectDispatch::read( + const std::string &oid, uint64_t object_no, uint64_t object_off, + uint64_t object_len, librados::snap_t snap_id, int op_flags, + const ZTracer::Trace &parent_trace, ceph::bufferlist* read_data, + io::ExtentMap* extent_map, int* object_dispatch_flags, + io::DispatchResult* dispatch_result, Context** on_finish, + Context* on_dispatched) { + auto cct = m_image_ctx->cct; + ldout(cct, 20) << "object_no=" << object_no << " " << object_off << "~" + << object_len << dendl; + + // if any failse, reads will go to rados + if(m_cache_client == nullptr || !m_cache_client->is_session_work() || + m_object_store == nullptr || !m_initialized) { + ldout(cct, 5) << "SRO cache client session failed " << dendl; + return false; + } + + CacheGenContextURef ctx = make_gen_lambda_context> + ([this, snap_id, read_data, dispatch_result, on_dispatched, + oid, object_off, object_len](ObjectCacheRequest* ack) { + handle_read_cache(ack, object_off, object_len, read_data, + dispatch_result, on_dispatched); + }); + + m_cache_client->lookup_object(m_image_ctx->data_ctx.get_namespace(), + m_image_ctx->data_ctx.get_id(), + (uint64_t)snap_id, oid, std::move(ctx)); + return true; +} + +template +void ParentCacheObjectDispatch::handle_read_cache( + ObjectCacheRequest* ack, uint64_t read_off, + uint64_t read_len, ceph::bufferlist* read_data, + io::DispatchResult* dispatch_result, Context* on_dispatched) { + auto cct = m_image_ctx->cct; + ldout(cct, 20) << dendl; + + if(ack->type != RBDSC_READ_REPLY) { + // go back to read rados + *dispatch_result = io::DISPATCH_RESULT_CONTINUE; + on_dispatched->complete(0); + return; + } + + ceph_assert(ack->type == RBDSC_READ_REPLY); + std::string file_path = ((ObjectCacheReadReplyData*)ack)->cache_path; + ceph_assert(file_path != ""); + + // try to read from parent image cache + int r = m_object_store->read_object(file_path, read_data, read_off, read_len, on_dispatched); + if(r < 0) { + // cache read error, fall back to read rados + *dispatch_result = io::DISPATCH_RESULT_CONTINUE; + on_dispatched->complete(0); + } + + *dispatch_result = io::DISPATCH_RESULT_COMPLETE; + on_dispatched->complete(r); +} + +template +int ParentCacheObjectDispatch::handle_register_client(bool reg) { + auto cct = m_image_ctx->cct; + ldout(cct, 20) << dendl; + + if (reg) { + ldout(cct, 20) << "SRO cache client open cache handler" << dendl; + m_object_store = new SharedPersistentObjectCacher(m_image_ctx, m_image_ctx->shared_cache_path); + } + return 0; +} + +} // namespace cache +} // namespace librbd + +template class librbd::cache::ParentCacheObjectDispatch; diff --git a/src/librbd/cache/ParentCacheObjectDispatch.h b/src/librbd/cache/ParentCacheObjectDispatch.h new file mode 100644 index 000000000000..5a10d5754e9c --- /dev/null +++ b/src/librbd/cache/ParentCacheObjectDispatch.h @@ -0,0 +1,132 @@ +// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*- +// vim: ts=8 sw=2 smarttab + +#ifndef CEPH_LIBRBD_CACHE_PARENT_CACHER_OBJECT_DISPATCH_H +#define CEPH_LIBRBD_CACHE_PARENT_CACHER_OBJECT_DISPATCH_H + +#include "common/Mutex.h" +#include "SharedPersistentObjectCacher.h" +#include "librbd/io/ObjectDispatchInterface.h" +#include "tools/immutable_object_cache/CacheClient.h" +#include "tools/immutable_object_cache/Types.h" + +using namespace ceph::immutable_obj_cache; + +namespace librbd { + +class ImageCtx; + +namespace cache { + +template +class ParentCacheObjectDispatch : public io::ObjectDispatchInterface { +public: + static ParentCacheObjectDispatch* create(ImageCtxT* image_ctx) { + return new ParentCacheObjectDispatch(image_ctx); + } + + ParentCacheObjectDispatch(ImageCtxT* image_ctx); + ~ParentCacheObjectDispatch() override; + + io::ObjectDispatchLayer get_object_dispatch_layer() const override { + return io::OBJECT_DISPATCH_LAYER_PARENT_CACHE; + } + + void init(); + void shut_down(Context* on_finish) { + m_image_ctx->op_work_queue->queue(on_finish, 0); + } + + bool read( + const std::string &oid, uint64_t object_no, uint64_t object_off, + uint64_t object_len, librados::snap_t snap_id, int op_flags, + const ZTracer::Trace &parent_trace, ceph::bufferlist* read_data, + io::ExtentMap* extent_map, int* object_dispatch_flags, + io::DispatchResult* dispatch_result, Context** on_finish, + Context* on_dispatched) override; + + bool discard( + const std::string &oid, uint64_t object_no, uint64_t object_off, + uint64_t object_len, const ::SnapContext &snapc, int discard_flags, + const ZTracer::Trace &parent_trace, int* object_dispatch_flags, + uint64_t* journal_tid, io::DispatchResult* dispatch_result, + Context** on_finish, Context* on_dispatched) { + return false; + } + + bool write( + const std::string &oid, uint64_t object_no, uint64_t object_off, + ceph::bufferlist&& data, const ::SnapContext &snapc, int op_flags, + const ZTracer::Trace &parent_trace, int* object_dispatch_flags, + uint64_t* journal_tid, io::DispatchResult* dispatch_result, + Context** on_finish, Context* on_dispatched) { + return false; + } + + bool write_same( + const std::string &oid, uint64_t object_no, uint64_t object_off, + uint64_t object_len, io::Extents&& buffer_extents, + ceph::bufferlist&& data, const ::SnapContext &snapc, int op_flags, + const ZTracer::Trace &parent_trace, int* object_dispatch_flags, + uint64_t* journal_tid, io::DispatchResult* dispatch_result, + Context** on_finish, Context* on_dispatched) { + return false; + } + + bool compare_and_write( + const std::string &oid, uint64_t object_no, uint64_t object_off, + ceph::bufferlist&& cmp_data, ceph::bufferlist&& write_data, + const ::SnapContext &snapc, int op_flags, + const ZTracer::Trace &parent_trace, uint64_t* mismatch_offset, + int* object_dispatch_flags, uint64_t* journal_tid, + io::DispatchResult* dispatch_result, Context** on_finish, + Context* on_dispatched) { + return false; + } + + bool flush( + io::FlushSource flush_source, const ZTracer::Trace &parent_trace, + uint64_t* journal_id, io::DispatchResult* dispatch_result, + Context** on_finish, Context* on_dispatched) { + return false; + } + + bool invalidate_cache(Context* on_finish) { + return false; + } + + bool reset_existence_cache(Context* on_finish) { + return false; + } + + void extent_overwritten( + uint64_t object_no, uint64_t object_off, uint64_t object_len, + uint64_t journal_tid, uint64_t new_journal_tid) { + } + + bool get_state() { + return m_initialized; + } + + CacheClientT *m_cache_client = nullptr; + ImageCtxT* m_image_ctx; + +private: + + void handle_read_cache( + ObjectCacheRequest* ack, uint64_t read_off, + uint64_t read_len, ceph::bufferlist* read_data, + io::DispatchResult* dispatch_result, + Context* on_dispatched); + int handle_register_client(bool reg); + + SharedPersistentObjectCacher *m_object_store = nullptr; + bool m_initialized; +}; + +} // namespace cache +} // namespace librbd + +extern template class librbd::cache::ParentCacheObjectDispatch; + +#endif // CEPH_LIBRBD_CACHE_PARENT_CACHER_OBJECT_DISPATCH_H diff --git a/src/librbd/cache/SharedPersistentObjectCacher.cc b/src/librbd/cache/SharedPersistentObjectCacher.cc index ac0bbf50969b..3abc4df36066 100644 --- a/src/librbd/cache/SharedPersistentObjectCacher.cc +++ b/src/librbd/cache/SharedPersistentObjectCacher.cc @@ -16,8 +16,7 @@ namespace cache { template SharedPersistentObjectCacher::SharedPersistentObjectCacher(I *image_ctx, std::string cache_path) - : m_image_ctx(image_ctx), m_cache_path(cache_path), - m_file_map_lock("librbd::cache::SharedObjectCacher::filemaplock") { + : m_image_ctx(image_ctx) { auto *cct = m_image_ctx->cct; ldout(cct, 20) << dendl; } diff --git a/src/librbd/cache/SharedPersistentObjectCacher.h b/src/librbd/cache/SharedPersistentObjectCacher.h index f9f7fc245d30..c7457000d312 100644 --- a/src/librbd/cache/SharedPersistentObjectCacher.h +++ b/src/librbd/cache/SharedPersistentObjectCacher.h @@ -30,8 +30,6 @@ public: private: ImageCtxT *m_image_ctx; - std::string m_cache_path; - Mutex m_file_map_lock; }; } // namespace cache diff --git a/src/librbd/cache/SharedReadOnlyObjectDispatch.cc b/src/librbd/cache/SharedReadOnlyObjectDispatch.cc deleted file mode 100644 index d763439e3eaf..000000000000 --- a/src/librbd/cache/SharedReadOnlyObjectDispatch.cc +++ /dev/null @@ -1,168 +0,0 @@ -// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*- -// vim: ts=8 sw=2 smarttab - -#include "common/WorkQueue.h" -#include "librbd/ImageCtx.h" -#include "librbd/Journal.h" -#include "librbd/Utils.h" -#include "librbd/io/ObjectDispatchSpec.h" -#include "librbd/io/ObjectDispatcher.h" -#include "librbd/io/Utils.h" -#include "librbd/cache/SharedReadOnlyObjectDispatch.h" -#include "osd/osd_types.h" -#include "osdc/WritebackHandler.h" - -#include - -#define dout_subsys ceph_subsys_rbd -#undef dout_prefix -#define dout_prefix *_dout << "librbd::cache::SharedReadOnlyObjectDispatch: " \ - << this << " " << __func__ << ": " - -namespace librbd { -namespace cache { - -template -SharedReadOnlyObjectDispatch::SharedReadOnlyObjectDispatch( - I* image_ctx) : m_image_ctx(image_ctx), m_cache_client(nullptr), - m_initialzed(false), m_object_store(nullptr) { -} - -template -SharedReadOnlyObjectDispatch::~SharedReadOnlyObjectDispatch() { - delete m_object_store; - delete m_cache_client; -} - -// TODO if connect fails, init will return error to high layer. -template -void SharedReadOnlyObjectDispatch::init() { - auto cct = m_image_ctx->cct; - ldout(cct, 5) << dendl; - - if (m_image_ctx->parent != nullptr) { - ldout(cct, 5) << "child image: skipping" << dendl; - return; - } - - ldout(cct, 5) << "parent image: setup SRO cache client" << dendl; - - std::string controller_path = ((CephContext*)cct)->_conf.get_val("immutable_object_cache_sock"); - if(m_cache_client == nullptr) { - m_cache_client = new C(controller_path.c_str(), m_image_ctx->cct); - } - m_cache_client->run(); - - int ret = m_cache_client->connect(); - if (ret < 0) { - ldout(cct, 5) << "SRO cache client fail to connect with local controller: " - << "please start ceph-immutable-object-cache daemon" - << dendl; - } else { - ldout(cct, 5) << "SRO cache client to register volume " - << "name = " << m_image_ctx->id - << " on ceph-immutable-object-cache daemon" - << dendl; - - auto ctx = new FunctionContext([this](bool reg) { - handle_register_client(reg); - }); - - ret = m_cache_client->register_client(ctx); - - if (ret >= 0) { - // add ourself to the IO object dispatcher chain - m_image_ctx->io_object_dispatcher->register_object_dispatch(this); - m_initialzed = true; - } - } -} - -template -bool SharedReadOnlyObjectDispatch::read( - const std::string &oid, uint64_t object_no, uint64_t object_off, - uint64_t object_len, librados::snap_t snap_id, int op_flags, - const ZTracer::Trace &parent_trace, ceph::bufferlist* read_data, - io::ExtentMap* extent_map, int* object_dispatch_flags, - io::DispatchResult* dispatch_result, Context** on_finish, - Context* on_dispatched) { - auto cct = m_image_ctx->cct; - ldout(cct, 20) << "object_no=" << object_no << " " << object_off << "~" - << object_len << dendl; - - // if any failse, reads will go to rados - if(!m_cache_client->is_session_work() || m_cache_client == nullptr || - m_object_store == nullptr || !m_initialzed) { - ldout(cct, 5) << "SRO cache client session failed " << dendl; - return false; - } - - CacheGenContextURef ctx = make_gen_lambda_context> - ([this, snap_id, read_data, dispatch_result, on_dispatched, - oid, object_off, object_len](ObjectCacheRequest* ack) { - handle_read_cache(ack, object_off, object_len, read_data, - dispatch_result, on_dispatched); - }); - - m_cache_client->lookup_object(m_image_ctx->data_ctx.get_namespace(), - m_image_ctx->data_ctx.get_id(), - (uint64_t)snap_id, oid, std::move(ctx)); - return true; -} - -template -void SharedReadOnlyObjectDispatch::handle_read_cache( - ObjectCacheRequest* ack, uint64_t read_off, - uint64_t read_len, ceph::bufferlist* read_data, - io::DispatchResult* dispatch_result, Context* on_dispatched) { - auto cct = m_image_ctx->cct; - ldout(cct, 20) << dendl; - - if(ack->type != RBDSC_READ_REPLY) { - // go back to read rados - *dispatch_result = io::DISPATCH_RESULT_CONTINUE; - on_dispatched->complete(0); - return; - } - - ceph_assert(ack->type == RBDSC_READ_REPLY); - std::string file_path = ((ObjectCacheReadReplyData*)ack)->cache_path; - ceph_assert(file_path != ""); - - // try to read from parent image cache - int r = m_object_store->read_object(file_path, read_data, read_off, read_len, on_dispatched); - if(r < 0) { - // cache read error, fall back to read rados - *dispatch_result = io::DISPATCH_RESULT_CONTINUE; - on_dispatched->complete(0); - } - - *dispatch_result = io::DISPATCH_RESULT_COMPLETE; - //TODO(): complete in syncfile - on_dispatched->complete(r); -} - -template -int SharedReadOnlyObjectDispatch::handle_register_client(bool reg) { - auto cct = m_image_ctx->cct; - ldout(cct, 20) << dendl; - - if (reg) { - ldout(cct, 20) << "SRO cache client open cache handler" << dendl; - m_object_store = new SharedPersistentObjectCacher(m_image_ctx, m_image_ctx->shared_cache_path); - } - return 0; -} - -template -void SharedReadOnlyObjectDispatch::client_handle_request(std::string msg) { - auto cct = m_image_ctx->cct; - ldout(cct, 20) << dendl; - -} - -} // namespace cache -} // namespace librbd - -template class librbd::cache::SharedReadOnlyObjectDispatch; diff --git a/src/librbd/cache/SharedReadOnlyObjectDispatch.h b/src/librbd/cache/SharedReadOnlyObjectDispatch.h deleted file mode 100644 index cd1d566c332c..000000000000 --- a/src/librbd/cache/SharedReadOnlyObjectDispatch.h +++ /dev/null @@ -1,133 +0,0 @@ -// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*- -// vim: ts=8 sw=2 smarttab - -#ifndef CEPH_LIBRBD_CACHE_SHARED_PERSISTENT_OBJECT_CACHER_OBJECT_DISPATCH_H -#define CEPH_LIBRBD_CACHE_SHARED_PERSISTENT_OBJECT_CACHER_OBJECT_DISPATCH_H - -#include "common/Mutex.h" -#include "SharedPersistentObjectCacher.h" -#include "librbd/io/ObjectDispatchInterface.h" -#include "tools/immutable_object_cache/CacheClient.h" -#include "tools/immutable_object_cache/Types.h" - -using namespace ceph::immutable_obj_cache; - -namespace librbd { - -class ImageCtx; - -namespace cache { - -template -class SharedReadOnlyObjectDispatch : public io::ObjectDispatchInterface { -public: - static SharedReadOnlyObjectDispatch* create(ImageCtxT* image_ctx) { - return new SharedReadOnlyObjectDispatch(image_ctx); - } - - SharedReadOnlyObjectDispatch(ImageCtxT* image_ctx); - ~SharedReadOnlyObjectDispatch() override; - - io::ObjectDispatchLayer get_object_dispatch_layer() const override { - return io::OBJECT_DISPATCH_LAYER_SHARED_PERSISTENT_CACHE; - } - - void init(); - void shut_down(Context* on_finish) { - m_image_ctx->op_work_queue->queue(on_finish, 0); - } - - bool read( - const std::string &oid, uint64_t object_no, uint64_t object_off, - uint64_t object_len, librados::snap_t snap_id, int op_flags, - const ZTracer::Trace &parent_trace, ceph::bufferlist* read_data, - io::ExtentMap* extent_map, int* object_dispatch_flags, - io::DispatchResult* dispatch_result, Context** on_finish, - Context* on_dispatched) override; - - bool discard( - const std::string &oid, uint64_t object_no, uint64_t object_off, - uint64_t object_len, const ::SnapContext &snapc, int discard_flags, - const ZTracer::Trace &parent_trace, int* object_dispatch_flags, - uint64_t* journal_tid, io::DispatchResult* dispatch_result, - Context** on_finish, Context* on_dispatched) { - return false; - } - - bool write( - const std::string &oid, uint64_t object_no, uint64_t object_off, - ceph::bufferlist&& data, const ::SnapContext &snapc, int op_flags, - const ZTracer::Trace &parent_trace, int* object_dispatch_flags, - uint64_t* journal_tid, io::DispatchResult* dispatch_result, - Context** on_finish, Context* on_dispatched) { - return false; - } - - bool write_same( - const std::string &oid, uint64_t object_no, uint64_t object_off, - uint64_t object_len, io::Extents&& buffer_extents, - ceph::bufferlist&& data, const ::SnapContext &snapc, int op_flags, - const ZTracer::Trace &parent_trace, int* object_dispatch_flags, - uint64_t* journal_tid, io::DispatchResult* dispatch_result, - Context** on_finish, Context* on_dispatched) { - return false; - } - - bool compare_and_write( - const std::string &oid, uint64_t object_no, uint64_t object_off, - ceph::bufferlist&& cmp_data, ceph::bufferlist&& write_data, - const ::SnapContext &snapc, int op_flags, - const ZTracer::Trace &parent_trace, uint64_t* mismatch_offset, - int* object_dispatch_flags, uint64_t* journal_tid, - io::DispatchResult* dispatch_result, Context** on_finish, - Context* on_dispatched) { - return false; - } - - bool flush( - io::FlushSource flush_source, const ZTracer::Trace &parent_trace, - uint64_t* journal_id, io::DispatchResult* dispatch_result, - Context** on_finish, Context* on_dispatched) { - return false; - } - - bool invalidate_cache(Context* on_finish) { - return false; - } - - bool reset_existence_cache(Context* on_finish) { - return false; - } - - void extent_overwritten( - uint64_t object_no, uint64_t object_off, uint64_t object_len, - uint64_t journal_tid, uint64_t new_journal_tid) { - } - - bool get_state() { - return m_initialzed; - } - - CacheClientT *m_cache_client = nullptr; - ImageCtxT* m_image_ctx; - -private: - - void handle_read_cache( - ObjectCacheRequest* ack, uint64_t read_off, - uint64_t read_len, ceph::bufferlist* read_data, - io::DispatchResult* dispatch_result, - Context* on_dispatched); - int handle_register_client(bool reg); - void client_handle_request(std::string msg); - - SharedPersistentObjectCacher *m_object_store = nullptr; - bool m_initialzed; -}; - -} // namespace cache -} // namespace librbd - -extern template class librbd::cache::SharedReadOnlyObjectDispatch; - -#endif // CEPH_LIBRBD_CACHE_OBJECT_CACHER_OBJECT_DISPATCH_H diff --git a/src/librbd/image/OpenRequest.cc b/src/librbd/image/OpenRequest.cc index f4cf7a7bf639..83d94cf36b9e 100644 --- a/src/librbd/image/OpenRequest.cc +++ b/src/librbd/image/OpenRequest.cc @@ -9,7 +9,7 @@ #include "librbd/Utils.h" #include "librbd/cache/ObjectCacherObjectDispatch.h" #include "librbd/cache/WriteAroundObjectDispatch.h" -#include "librbd/cache/SharedReadOnlyObjectDispatch.cc" +#include "librbd/cache/ParentCacheObjectDispatch.cc" #include "librbd/image/CloseRequest.h" #include "librbd/image/RefreshRequest.h" #include "librbd/image/SetSnapRequest.h" @@ -525,7 +525,7 @@ Context *OpenRequest::send_init_cache(int *result) { // enable Shared Read-only cache for parent image if (m_image_ctx->child != nullptr && m_image_ctx->parent_cache_enabled ) { ldout(cct, 10) << this << " " << "setting up parent cache"<< dendl; - auto sro_cache = cache::SharedReadOnlyObjectDispatch::create(m_image_ctx); + auto sro_cache = cache::ParentCacheObjectDispatch::create(m_image_ctx); sro_cache->init(); } return send_register_watch(result); diff --git a/src/librbd/io/Types.h b/src/librbd/io/Types.h index 69605433c567..53c8f4d74f76 100644 --- a/src/librbd/io/Types.h +++ b/src/librbd/io/Types.h @@ -61,7 +61,7 @@ enum ObjectDispatchLayer { OBJECT_DISPATCH_LAYER_NONE = 0, OBJECT_DISPATCH_LAYER_CACHE, OBJECT_DISPATCH_LAYER_JOURNAL, - OBJECT_DISPATCH_LAYER_SHARED_PERSISTENT_CACHE, + OBJECT_DISPATCH_LAYER_PARENT_CACHE, OBJECT_DISPATCH_LAYER_SCHEDULER, OBJECT_DISPATCH_LAYER_CORE, OBJECT_DISPATCH_LAYER_LAST diff --git a/src/test/librbd/cache/test_mock_ParentImageCache.cc b/src/test/librbd/cache/test_mock_ParentImageCache.cc index 68e53e580610..d37e48e2ed43 100644 --- a/src/test/librbd/cache/test_mock_ParentImageCache.cc +++ b/src/test/librbd/cache/test_mock_ParentImageCache.cc @@ -9,7 +9,7 @@ #include "include/Context.h" #include "tools/immutable_object_cache/CacheClient.h" #include "test/immutable_object_cache/MockCacheDaemon.h" -#include "librbd/cache/SharedReadOnlyObjectDispatch.h" +#include "librbd/cache/ParentCacheObjectDispatch.h" #include "librbd/cache/SharedPersistentObjectCacher.h" #include "test/librbd/test_mock_fixture.h" #include "test/librbd/mock/MockImageCtx.h" @@ -33,9 +33,9 @@ struct MockParentImageCacheImageCtx : public MockImageCtx { }; -#include "librbd/cache/SharedReadOnlyObjectDispatch.cc" +#include "librbd/cache/ParentCacheObjectDispatch.cc" #include "librbd/cache/SharedPersistentObjectCacher.cc" -template class librbd::cache::SharedReadOnlyObjectDispatch; +template class librbd::cache::ParentCacheObjectDispatch; template class librbd::cache::SharedPersistentObjectCacher; namespace librbd { @@ -50,7 +50,7 @@ using ::testing::WithArgs; class TestMockParentImageCache : public TestMockFixture { public : - typedef cache::SharedReadOnlyObjectDispatch MockParentImageCache; + typedef cache::ParentCacheObjectDispatch MockParentImageCache; // ====== mock cache client ==== void expect_cache_run(MockParentImageCache& mparent_image_cache, bool ret_val) { @@ -150,7 +150,7 @@ TEST_F(TestMockParentImageCache, test_initialization_success) { mock_parent_image_cache->init(); ASSERT_EQ(mock_parent_image_cache->get_object_dispatch_layer(), - io::OBJECT_DISPATCH_LAYER_SHARED_PERSISTENT_CACHE); + io::OBJECT_DISPATCH_LAYER_PARENT_CACHE); ASSERT_EQ(mock_parent_image_cache->get_state(), true); ASSERT_EQ(mock_parent_image_cache->m_cache_client->is_session_work(), true); @@ -179,7 +179,7 @@ TEST_F(TestMockParentImageCache, test_initialization_fail_at_connect) { // initialization fails. ASSERT_EQ(mock_parent_image_cache->get_object_dispatch_layer(), - io::OBJECT_DISPATCH_LAYER_SHARED_PERSISTENT_CACHE); + io::OBJECT_DISPATCH_LAYER_PARENT_CACHE); ASSERT_EQ(mock_parent_image_cache->get_state(), false); ASSERT_EQ(mock_parent_image_cache->m_cache_client->is_session_work(), false); @@ -212,7 +212,7 @@ TEST_F(TestMockParentImageCache, test_initialization_fail_at_register) { mock_parent_image_cache->init(); ASSERT_EQ(mock_parent_image_cache->get_object_dispatch_layer(), - io::OBJECT_DISPATCH_LAYER_SHARED_PERSISTENT_CACHE); + io::OBJECT_DISPATCH_LAYER_PARENT_CACHE); ASSERT_EQ(mock_parent_image_cache->get_state(), false); ASSERT_EQ(mock_parent_image_cache->m_cache_client->is_session_work(), false); @@ -288,7 +288,7 @@ TEST_F(TestMockParentImageCache, test_read) { mock_parent_image_cache->init(); ASSERT_EQ(mock_parent_image_cache->get_object_dispatch_layer(), - io::OBJECT_DISPATCH_LAYER_SHARED_PERSISTENT_CACHE); + io::OBJECT_DISPATCH_LAYER_PARENT_CACHE); ASSERT_EQ(mock_parent_image_cache->get_state(), true); ASSERT_EQ(mock_parent_image_cache->m_cache_client->is_session_work(), true);