summaryrefslogtreecommitdiffstats
path: root/src/librbd/ImageCtx.h
diff options
context:
space:
mode:
Diffstat (limited to 'src/librbd/ImageCtx.h')
-rw-r--r--src/librbd/ImageCtx.h368
1 files changed, 368 insertions, 0 deletions
diff --git a/src/librbd/ImageCtx.h b/src/librbd/ImageCtx.h
new file mode 100644
index 000000000..9a432c764
--- /dev/null
+++ b/src/librbd/ImageCtx.h
@@ -0,0 +1,368 @@
+// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
+// vim: ts=8 sw=2 smarttab
+#ifndef CEPH_LIBRBD_IMAGECTX_H
+#define CEPH_LIBRBD_IMAGECTX_H
+
+#include "include/int_types.h"
+
+#include <atomic>
+#include <list>
+#include <map>
+#include <memory>
+#include <set>
+#include <string>
+#include <vector>
+
+#include "common/Timer.h"
+#include "common/ceph_mutex.h"
+#include "common/config_proxy.h"
+#include "common/event_socket.h"
+#include "common/Readahead.h"
+#include "common/snap_types.h"
+#include "common/zipkin_trace.h"
+
+#include "include/common_fwd.h"
+#include "include/buffer_fwd.h"
+#include "include/rbd/librbd.hpp"
+#include "include/rbd_types.h"
+#include "include/types.h"
+#include "include/xlist.h"
+
+#include "cls/rbd/cls_rbd_types.h"
+#include "cls/rbd/cls_rbd_client.h"
+#include "librbd/AsyncRequest.h"
+#include "librbd/Types.h"
+
+#include <boost/lockfree/policies.hpp>
+#include <boost/lockfree/queue.hpp>
+
+namespace neorados {
+class IOContext;
+class RADOS;
+} // namespace neorados
+
+namespace librbd {
+
+ struct AsioEngine;
+ template <typename> class ConfigWatcher;
+ template <typename> class ExclusiveLock;
+ template <typename> class ImageState;
+ template <typename> class ImageWatcher;
+ template <typename> class Journal;
+ class LibrbdAdminSocketHook;
+ template <typename> class ObjectMap;
+ template <typename> class Operations;
+ template <typename> class PluginRegistry;
+
+ namespace asio { struct ContextWQ; }
+ namespace crypto { template <typename> class EncryptionFormat; }
+ namespace exclusive_lock { struct Policy; }
+ namespace io {
+ class AioCompletion;
+ class AsyncOperation;
+ template <typename> class CopyupRequest;
+ enum class ImageArea;
+ struct ImageDispatcherInterface;
+ struct ObjectDispatcherInterface;
+ }
+ namespace journal { struct Policy; }
+
+ namespace operation {
+ template <typename> class ResizeRequest;
+ }
+
+ struct ImageCtx {
+ typedef std::pair<cls::rbd::SnapshotNamespace, std::string> SnapKey;
+ struct SnapKeyComparator {
+ inline bool operator()(const SnapKey& lhs, const SnapKey& rhs) const {
+ // only compare by namespace type and name
+ if (lhs.first.index() != rhs.first.index()) {
+ return lhs.first.index() < rhs.first.index();
+ }
+ return lhs.second < rhs.second;
+ }
+ };
+
+ static const std::string METADATA_CONF_PREFIX;
+
+ CephContext *cct;
+ ConfigProxy config;
+ std::set<std::string> config_overrides;
+
+ PerfCounters *perfcounter;
+ struct rbd_obj_header_ondisk header;
+ ::SnapContext snapc;
+ std::vector<librados::snap_t> snaps; // this mirrors snapc.snaps, but is in
+ // a format librados can understand
+ std::map<librados::snap_t, SnapInfo> snap_info;
+ std::map<SnapKey, librados::snap_t, SnapKeyComparator> snap_ids;
+ uint64_t open_snap_id = CEPH_NOSNAP;
+ uint64_t snap_id;
+ bool snap_exists; // false if our snap_id was deleted
+ // whether the image was opened read-only. cannot be changed after opening
+ bool read_only;
+ uint32_t read_only_flags = 0U;
+ uint32_t read_only_mask = ~0U;
+
+ std::map<rados::cls::lock::locker_id_t,
+ rados::cls::lock::locker_info_t> lockers;
+ bool exclusive_locked;
+ std::string lock_tag;
+
+ std::string name;
+ cls::rbd::SnapshotNamespace snap_namespace;
+ std::string snap_name;
+
+ std::shared_ptr<AsioEngine> asio_engine;
+
+ // New ASIO-style RADOS API
+ neorados::RADOS& rados_api;
+
+ // Legacy RADOS API
+ librados::IoCtx data_ctx;
+ librados::IoCtx md_ctx;
+
+ ConfigWatcher<ImageCtx> *config_watcher = nullptr;
+ ImageWatcher<ImageCtx> *image_watcher;
+ Journal<ImageCtx> *journal;
+
+ /**
+ * Lock ordering:
+ *
+ * owner_lock, image_lock
+ * async_op_lock, timestamp_lock
+ */
+ ceph::shared_mutex owner_lock; // protects exclusive lock leadership updates
+ mutable ceph::shared_mutex image_lock; // protects snapshot-related member variables,
+ // features (and associated helper classes), and flags
+ // protects access to the mutable image metadata that
+ // isn't guarded by other locks below, and blocks writes
+ // when held exclusively, so snapshots can be consistent.
+ // Fields guarded include:
+ // total_bytes_read
+ // exclusive_locked
+ // lock_tag
+ // lockers
+ // object_map
+ // parent_md and parent
+ // encryption_format
+
+ ceph::shared_mutex timestamp_lock; // protects (create/access/modify)_timestamp
+ ceph::mutex async_ops_lock; // protects async_ops and async_requests
+ ceph::mutex copyup_list_lock; // protects copyup_waiting_list
+
+ unsigned extra_read_flags; // librados::OPERATION_*
+
+ bool old_format;
+ uint8_t order;
+ uint64_t size;
+ uint64_t features;
+ std::string object_prefix;
+ char *format_string;
+ std::string header_oid;
+ std::string id; // only used for new-format images
+ ParentImageInfo parent_md;
+ ImageCtx *parent;
+ ImageCtx *child = nullptr;
+ MigrationInfo migration_info;
+ cls::rbd::GroupSpec group_spec;
+ uint64_t stripe_unit, stripe_count;
+ uint64_t flags;
+ uint64_t op_features = 0;
+ bool operations_disabled = false;
+ utime_t create_timestamp;
+ utime_t access_timestamp;
+ utime_t modify_timestamp;
+
+ file_layout_t layout;
+
+ Readahead readahead;
+ std::atomic<uint64_t> total_bytes_read = {0};
+
+ std::map<uint64_t, io::CopyupRequest<ImageCtx>*> copyup_list;
+
+ xlist<io::AsyncOperation*> async_ops;
+ xlist<AsyncRequest<>*> async_requests;
+ std::list<Context*> async_requests_waiters;
+
+ ImageState<ImageCtx> *state;
+ Operations<ImageCtx> *operations;
+
+ ExclusiveLock<ImageCtx> *exclusive_lock;
+ ObjectMap<ImageCtx> *object_map;
+
+ xlist<operation::ResizeRequest<ImageCtx>*> resize_reqs;
+
+ io::ImageDispatcherInterface *io_image_dispatcher = nullptr;
+ io::ObjectDispatcherInterface *io_object_dispatcher = nullptr;
+
+ asio::ContextWQ *op_work_queue;
+
+ PluginRegistry<ImageCtx>* plugin_registry;
+
+ using Completions = boost::lockfree::queue<io::AioCompletion*>;
+
+ Completions event_socket_completions;
+ EventSocket event_socket;
+
+ bool ignore_migrating = false;
+ bool disable_zero_copy = false;
+ bool enable_sparse_copyup = false;
+
+ /// Cached latency-sensitive configuration settings
+ bool non_blocking_aio;
+ bool cache;
+ uint64_t sparse_read_threshold_bytes;
+ uint64_t readahead_max_bytes = 0;
+ uint64_t readahead_disable_after_bytes = 0;
+ bool clone_copy_on_read;
+ bool enable_alloc_hint;
+ uint32_t alloc_hint_flags = 0U;
+ uint32_t read_flags = 0U; // librados::OPERATION_*
+ uint32_t discard_granularity_bytes = 0;
+ bool blkin_trace_all;
+ uint64_t mirroring_replay_delay;
+ uint64_t mtime_update_interval;
+ uint64_t atime_update_interval;
+
+ LibrbdAdminSocketHook *asok_hook;
+
+ exclusive_lock::Policy *exclusive_lock_policy = nullptr;
+ journal::Policy *journal_policy = nullptr;
+
+ ZTracer::Endpoint trace_endpoint;
+
+ std::unique_ptr<crypto::EncryptionFormat<ImageCtx>> encryption_format;
+
+ // unit test mock helpers
+ static ImageCtx* create(const std::string &image_name,
+ const std::string &image_id,
+ const char *snap, IoCtx& p, bool read_only) {
+ return new ImageCtx(image_name, image_id, snap, p, read_only);
+ }
+ static ImageCtx* create(const std::string &image_name,
+ const std::string &image_id,
+ librados::snap_t snap_id, IoCtx& p,
+ bool read_only) {
+ return new ImageCtx(image_name, image_id, snap_id, p, read_only);
+ }
+
+ /**
+ * Either image_name or image_id must be set.
+ * If id is not known, pass the empty std::string,
+ * and init() will look it up.
+ */
+ ImageCtx(const std::string &image_name, const std::string &image_id,
+ const char *snap, IoCtx& p, bool read_only);
+ ImageCtx(const std::string &image_name, const std::string &image_id,
+ librados::snap_t snap_id, IoCtx& p, bool read_only);
+ ~ImageCtx();
+ void init();
+ void shutdown();
+ void init_layout(int64_t pool_id);
+ void perf_start(std::string name);
+ void perf_stop();
+ void set_read_flag(unsigned flag);
+ int get_read_flags(librados::snap_t snap_id);
+ int snap_set(uint64_t snap_id);
+ void snap_unset();
+ librados::snap_t get_snap_id(const cls::rbd::SnapshotNamespace& in_snap_namespace,
+ const std::string& in_snap_name) const;
+ const SnapInfo* get_snap_info(librados::snap_t in_snap_id) const;
+ int get_snap_name(librados::snap_t in_snap_id,
+ std::string *out_snap_name) const;
+ int get_snap_namespace(librados::snap_t in_snap_id,
+ cls::rbd::SnapshotNamespace *out_snap_namespace) const;
+ int get_parent_spec(librados::snap_t in_snap_id,
+ cls::rbd::ParentImageSpec *pspec) const;
+ int is_snap_protected(librados::snap_t in_snap_id,
+ bool *is_protected) const;
+ int is_snap_unprotected(librados::snap_t in_snap_id,
+ bool *is_unprotected) const;
+
+ uint64_t get_current_size() const;
+ uint64_t get_object_size() const;
+ std::string get_object_name(uint64_t num) const;
+ uint64_t get_stripe_unit() const;
+ uint64_t get_stripe_count() const;
+ uint64_t get_stripe_period() const;
+ utime_t get_create_timestamp() const;
+ utime_t get_access_timestamp() const;
+ utime_t get_modify_timestamp() const;
+
+ void set_access_timestamp(utime_t at);
+ void set_modify_timestamp(utime_t at);
+
+ void add_snap(cls::rbd::SnapshotNamespace in_snap_namespace,
+ std::string in_snap_name,
+ librados::snap_t id,
+ uint64_t in_size, const ParentImageInfo &parent,
+ uint8_t protection_status, uint64_t flags, utime_t timestamp);
+ void rm_snap(cls::rbd::SnapshotNamespace in_snap_namespace,
+ std::string in_snap_name,
+ librados::snap_t id);
+ uint64_t get_image_size(librados::snap_t in_snap_id) const;
+ uint64_t get_area_size(io::ImageArea area) const;
+ uint64_t get_object_count(librados::snap_t in_snap_id) const;
+ bool test_features(uint64_t test_features) const;
+ bool test_features(uint64_t test_features,
+ const ceph::shared_mutex &in_image_lock) const;
+ bool test_op_features(uint64_t op_features) const;
+ bool test_op_features(uint64_t op_features,
+ const ceph::shared_mutex &in_image_lock) const;
+ int get_flags(librados::snap_t in_snap_id, uint64_t *flags) const;
+ int test_flags(librados::snap_t in_snap_id,
+ uint64_t test_flags, bool *flags_set) const;
+ int test_flags(librados::snap_t in_snap_id,
+ uint64_t test_flags, const ceph::shared_mutex &in_image_lock,
+ bool *flags_set) const;
+ int update_flags(librados::snap_t in_snap_id, uint64_t flag, bool enabled);
+
+ const ParentImageInfo* get_parent_info(librados::snap_t in_snap_id) const;
+ int64_t get_parent_pool_id(librados::snap_t in_snap_id) const;
+ std::string get_parent_image_id(librados::snap_t in_snap_id) const;
+ uint64_t get_parent_snap_id(librados::snap_t in_snap_id) const;
+ int get_parent_overlap(librados::snap_t in_snap_id,
+ uint64_t* raw_overlap) const;
+ std::pair<uint64_t, io::ImageArea> reduce_parent_overlap(
+ uint64_t raw_overlap, bool migration_write) const;
+ uint64_t prune_parent_extents(
+ std::vector<std::pair<uint64_t, uint64_t>>& image_extents,
+ io::ImageArea area, uint64_t raw_overlap, bool migration_write) const;
+
+ void register_watch(Context *on_finish);
+
+ void cancel_async_requests();
+ void cancel_async_requests(Context *on_finish);
+
+ void apply_metadata(const std::map<std::string, bufferlist> &meta,
+ bool thread_safe);
+
+ ExclusiveLock<ImageCtx> *create_exclusive_lock();
+ ObjectMap<ImageCtx> *create_object_map(uint64_t snap_id);
+ Journal<ImageCtx> *create_journal();
+
+ void set_image_name(const std::string &name);
+
+ void notify_update();
+ void notify_update(Context *on_finish);
+
+ exclusive_lock::Policy *get_exclusive_lock_policy() const;
+ void set_exclusive_lock_policy(exclusive_lock::Policy *policy);
+
+ journal::Policy *get_journal_policy() const;
+ void set_journal_policy(journal::Policy *policy);
+
+ void rebuild_data_io_context();
+ IOContext get_data_io_context() const;
+ IOContext duplicate_data_io_context() const;
+
+ static void get_timer_instance(CephContext *cct, SafeTimer **timer,
+ ceph::mutex **timer_lock);
+
+ private:
+ std::shared_ptr<neorados::IOContext> data_io_context;
+ };
+}
+
+#endif