api/Trash.cc
cache/ImageWriteback.cc
cache/ObjectCacherObjectDispatch.cc
- cache/SharedReadOnlyObjectDispatch.cc
+ cache/ParentCacheObjectDispatch.cc
cache/SharedPersistentObjectCacher.cc
cache/ObjectCacherWriteback.cc
cache/PassthroughImageCache.cc
--- /dev/null
+// -*- 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 <vector>
+
+#define dout_subsys ceph_subsys_rbd
+#undef dout_prefix
+#define dout_prefix *_dout << "librbd::cache::ParentCacheObjectDispatch: " \
+ << this << " " << __func__ << ": "
+
+namespace librbd {
+namespace cache {
+
+template <typename I, typename C>
+ParentCacheObjectDispatch<I, C>::ParentCacheObjectDispatch(
+ I* image_ctx) : m_image_ctx(image_ctx), m_cache_client(nullptr),
+ m_initialized(false), m_object_store(nullptr) {
+}
+
+template <typename I, typename C>
+ParentCacheObjectDispatch<I, C>::~ParentCacheObjectDispatch() {
+ delete m_object_store;
+ delete m_cache_client;
+}
+
+// TODO if connect fails, init will return error to high layer.
+template <typename I, typename C>
+void ParentCacheObjectDispatch<I, C>::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<std::string>("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 <typename I, typename C>
+bool ParentCacheObjectDispatch<I, C>::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<ObjectCacheRequest*,
+ std::function<void(ObjectCacheRequest*)>>
+ ([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 <typename I, typename C>
+void ParentCacheObjectDispatch<I, C>::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 <typename I, typename C>
+int ParentCacheObjectDispatch<I, C>::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<I>(m_image_ctx, m_image_ctx->shared_cache_path);
+ }
+ return 0;
+}
+
+} // namespace cache
+} // namespace librbd
+
+template class librbd::cache::ParentCacheObjectDispatch<librbd::ImageCtx, ceph::immutable_obj_cache::CacheClient>;
--- /dev/null
+// -*- 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 <typename ImageCtxT = ImageCtx, typename CacheClientT = CacheClient>
+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<ImageCtxT> *m_object_store = nullptr;
+ bool m_initialized;
+};
+
+} // namespace cache
+} // namespace librbd
+
+extern template class librbd::cache::ParentCacheObjectDispatch<librbd::ImageCtx, ceph::immutable_obj_cache::CacheClient>;
+
+#endif // CEPH_LIBRBD_CACHE_PARENT_CACHER_OBJECT_DISPATCH_H
template <typename I>
SharedPersistentObjectCacher<I>::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;
}
private:
ImageCtxT *m_image_ctx;
- std::string m_cache_path;
- Mutex m_file_map_lock;
};
} // namespace cache
+++ /dev/null
-// -*- 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 <vector>
-
-#define dout_subsys ceph_subsys_rbd
-#undef dout_prefix
-#define dout_prefix *_dout << "librbd::cache::SharedReadOnlyObjectDispatch: " \
- << this << " " << __func__ << ": "
-
-namespace librbd {
-namespace cache {
-
-template <typename I, typename C>
-SharedReadOnlyObjectDispatch<I, C>::SharedReadOnlyObjectDispatch(
- I* image_ctx) : m_image_ctx(image_ctx), m_cache_client(nullptr),
- m_initialzed(false), m_object_store(nullptr) {
-}
-
-template <typename I, typename C>
-SharedReadOnlyObjectDispatch<I, C>::~SharedReadOnlyObjectDispatch() {
- delete m_object_store;
- delete m_cache_client;
-}
-
-// TODO if connect fails, init will return error to high layer.
-template <typename I, typename C>
-void SharedReadOnlyObjectDispatch<I, C>::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<std::string>("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 <typename I, typename C>
-bool SharedReadOnlyObjectDispatch<I, C>::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<ObjectCacheRequest*,
- std::function<void(ObjectCacheRequest*)>>
- ([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 <typename I, typename C>
-void SharedReadOnlyObjectDispatch<I, C>::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 <typename I, typename C>
-int SharedReadOnlyObjectDispatch<I, C>::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<I>(m_image_ctx, m_image_ctx->shared_cache_path);
- }
- return 0;
-}
-
-template <typename I, typename C>
-void SharedReadOnlyObjectDispatch<I, C>::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<librbd::ImageCtx, ceph::immutable_obj_cache::CacheClient>;
+++ /dev/null
-// -*- 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 <typename ImageCtxT = ImageCtx, typename CacheClientT = CacheClient>
-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<ImageCtxT> *m_object_store = nullptr;
- bool m_initialzed;
-};
-
-} // namespace cache
-} // namespace librbd
-
-extern template class librbd::cache::SharedReadOnlyObjectDispatch<librbd::ImageCtx, ceph::immutable_obj_cache::CacheClient>;
-
-#endif // CEPH_LIBRBD_CACHE_OBJECT_CACHER_OBJECT_DISPATCH_H
#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"
// 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<I>::create(m_image_ctx);
+ auto sro_cache = cache::ParentCacheObjectDispatch<I>::create(m_image_ctx);
sro_cache->init();
}
return send_register_watch(result);
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
#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"
};
-#include "librbd/cache/SharedReadOnlyObjectDispatch.cc"
+#include "librbd/cache/ParentCacheObjectDispatch.cc"
#include "librbd/cache/SharedPersistentObjectCacher.cc"
-template class librbd::cache::SharedReadOnlyObjectDispatch<librbd::MockParentImageCacheImageCtx, MockCacheClient>;
+template class librbd::cache::ParentCacheObjectDispatch<librbd::MockParentImageCacheImageCtx, MockCacheClient>;
template class librbd::cache::SharedPersistentObjectCacher<librbd::MockParentImageCacheImageCtx>;
namespace librbd {
class TestMockParentImageCache : public TestMockFixture {
public :
- typedef cache::SharedReadOnlyObjectDispatch<librbd::MockParentImageCacheImageCtx, MockCacheClient> MockParentImageCache;
+ typedef cache::ParentCacheObjectDispatch<librbd::MockParentImageCacheImageCtx, MockCacheClient> MockParentImageCache;
// ====== mock cache client ====
void expect_cache_run(MockParentImageCache& mparent_image_cache, bool ret_val) {
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);
// 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);
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);
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);
projects / ceph-ci.git / commitdiff