1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
2 // vim: ts=8 sw=2 smarttab
3 #ifndef CEPH_LIBRBD_IMAGECTX_H
4 #define CEPH_LIBRBD_IMAGECTX_H
6 #include "include/int_types.h"
13 #include "common/event_socket.h"
14 #include "common/Mutex.h"
15 #include "common/Readahead.h"
16 #include "common/RWLock.h"
17 #include "common/snap_types.h"
18 #include "common/zipkin_trace.h"
20 #include "include/buffer_fwd.h"
21 #include "include/rbd/librbd.hpp"
22 #include "include/rbd_types.h"
23 #include "include/types.h"
24 #include "include/xlist.h"
25 #include "osdc/ObjectCacher.h"
27 #include "cls/rbd/cls_rbd_types.h"
28 #include "cls/rbd/cls_rbd_client.h"
29 #include "librbd/AsyncRequest.h"
30 #include "librbd/Types.h"
41 template <typename> class ExclusiveLock;
42 template <typename> class ImageState;
43 template <typename> class ImageWatcher;
44 template <typename> class Journal;
45 class LibrbdAdminSocketHook;
46 template <typename> class ObjectMap;
47 template <typename> class Operations;
48 class LibrbdWriteback;
50 namespace cache { struct ImageCache; }
51 namespace exclusive_lock { struct Policy; }
55 template <typename> class ImageRequestWQ;
58 namespace journal { struct Policy; }
61 template <typename> class ResizeRequest;
66 PerfCounters *perfcounter;
67 struct rbd_obj_header_ondisk header;
69 std::vector<librados::snap_t> snaps; // this mirrors snapc.snaps, but is in
70 // a format librados can understand
71 std::map<librados::snap_t, SnapInfo> snap_info;
72 std::map<std::pair<cls::rbd::SnapshotNamespace, std::string>, librados::snap_t> snap_ids;
74 bool snap_exists; // false if our snap_id was deleted
75 // whether the image was opened read-only. cannot be changed after opening
77 bool flush_encountered;
79 std::map<rados::cls::lock::locker_id_t,
80 rados::cls::lock::locker_info_t> lockers;
81 bool exclusive_locked;
85 cls::rbd::SnapshotNamespace snap_namespace;
86 std::string snap_name;
87 IoCtx data_ctx, md_ctx;
88 ImageWatcher<ImageCtx> *image_watcher;
89 Journal<ImageCtx> *journal;
94 * owner_lock, md_lock, cache_lock, snap_lock, parent_lock,
95 * object_map_lock, async_op_lock
97 RWLock owner_lock; // protects exclusive lock leadership updates
98 RWLock md_lock; // protects access to the mutable image metadata that
99 // isn't guarded by other locks below, and blocks writes
100 // when held exclusively, so snapshots can be consistent.
101 // Fields guarded include:
107 Mutex cache_lock; // used as client_lock for the ObjectCacher
108 RWLock snap_lock; // protects snapshot-related member variables,
109 // features (and associated helper classes), and flags
110 RWLock parent_lock; // protects parent_md and parent
111 RWLock object_map_lock; // protects object map updates and object_map itself
112 Mutex async_ops_lock; // protects async_ops and async_requests
113 Mutex copyup_list_lock; // protects copyup_waiting_list
114 Mutex completed_reqs_lock; // protects completed_reqs
116 unsigned extra_read_flags;
122 std::string object_prefix;
124 std::string header_oid;
125 std::string id; // only used for new-format images
126 ParentInfo parent_md;
128 cls::rbd::GroupSpec group_spec;
129 uint64_t stripe_unit, stripe_count;
131 utime_t create_timestamp;
133 file_layout_t layout;
135 cache::ImageCache *image_cache = nullptr;
136 ObjectCacher *object_cacher;
137 LibrbdWriteback *writeback_handler;
138 ObjectCacher::ObjectSet *object_set;
141 uint64_t total_bytes_read;
143 std::map<uint64_t, io::CopyupRequest*> copyup_list;
145 xlist<io::AsyncOperation*> async_ops;
146 xlist<AsyncRequest<>*> async_requests;
147 std::list<Context*> async_requests_waiters;
149 ImageState<ImageCtx> *state;
150 Operations<ImageCtx> *operations;
152 ExclusiveLock<ImageCtx> *exclusive_lock;
153 ObjectMap<ImageCtx> *object_map;
155 xlist<operation::ResizeRequest<ImageCtx>*> resize_reqs;
157 io::ImageRequestWQ<ImageCtx> *io_work_queue;
158 xlist<io::AioCompletion*> completed_reqs;
159 EventSocket event_socket;
161 ContextWQ *op_work_queue;
164 static const string METADATA_CONF_PREFIX;
165 bool non_blocking_aio;
167 bool cache_writethrough_until_flush;
169 uint64_t cache_max_dirty;
170 uint64_t cache_target_dirty;
171 double cache_max_dirty_age;
172 uint32_t cache_max_dirty_object;
173 bool cache_block_writes_upfront;
174 uint32_t concurrent_management_ops;
175 bool balance_snap_reads;
176 bool localize_snap_reads;
177 bool balance_parent_reads;
178 bool localize_parent_reads;
179 uint32_t readahead_trigger_requests;
180 uint64_t readahead_max_bytes;
181 uint64_t readahead_disable_after_bytes;
182 bool clone_copy_on_read;
183 bool blacklist_on_break_lock;
184 uint32_t blacklist_expire_seconds;
185 uint32_t request_timed_out_seconds;
186 bool enable_alloc_hint;
187 uint8_t journal_order;
188 uint8_t journal_splay_width;
189 double journal_commit_age;
190 int journal_object_flush_interval;
191 uint64_t journal_object_flush_bytes;
192 double journal_object_flush_age;
193 std::string journal_pool;
194 uint32_t journal_max_payload_bytes;
195 int journal_max_concurrent_object_sets;
196 bool mirroring_resync_after_disconnect;
197 int mirroring_replay_delay;
198 bool skip_partial_discard;
199 bool blkin_trace_all;
201 LibrbdAdminSocketHook *asok_hook;
203 exclusive_lock::Policy *exclusive_lock_policy = nullptr;
204 journal::Policy *journal_policy = nullptr;
206 ZTracer::Endpoint trace_endpoint;
208 static bool _filter_metadata_confs(const string &prefix, std::map<string, bool> &configs,
209 const map<string, bufferlist> &pairs, map<string, bufferlist> *res);
211 // unit test mock helpers
212 static ImageCtx* create(const std::string &image_name,
213 const std::string &image_id,
214 const char *snap, IoCtx& p, bool read_only) {
215 return new ImageCtx(image_name, image_id, snap, p, read_only);
222 * Either image_name or image_id must be set.
223 * If id is not known, pass the empty std::string,
224 * and init() will look it up.
226 ImageCtx(const std::string &image_name, const std::string &image_id,
227 const char *snap, IoCtx& p, bool read_only);
232 void perf_start(std::string name);
234 void set_read_flag(unsigned flag);
235 int get_read_flags(librados::snap_t snap_id);
236 int snap_set(cls::rbd::SnapshotNamespace in_snap_namespace,
237 std::string in_snap_name);
239 librados::snap_t get_snap_id(cls::rbd::SnapshotNamespace in_snap_namespace,
240 std::string in_snap_name) const;
241 const SnapInfo* get_snap_info(librados::snap_t in_snap_id) const;
242 int get_snap_name(librados::snap_t in_snap_id,
243 std::string *out_snap_name) const;
244 int get_snap_namespace(librados::snap_t in_snap_id,
245 cls::rbd::SnapshotNamespace *out_snap_namespace) const;
246 int get_parent_spec(librados::snap_t in_snap_id,
247 ParentSpec *pspec) const;
248 int is_snap_protected(librados::snap_t in_snap_id,
249 bool *is_protected) const;
250 int is_snap_unprotected(librados::snap_t in_snap_id,
251 bool *is_unprotected) const;
253 uint64_t get_current_size() const;
254 uint64_t get_object_size() const;
255 string get_object_name(uint64_t num) const;
256 uint64_t get_stripe_unit() const;
257 uint64_t get_stripe_count() const;
258 uint64_t get_stripe_period() const;
259 utime_t get_create_timestamp() const;
261 void add_snap(cls::rbd::SnapshotNamespace in_snap_namespace,
262 std::string in_snap_name,
264 uint64_t in_size, const ParentInfo &parent,
265 uint8_t protection_status, uint64_t flags, utime_t timestamp);
266 void rm_snap(cls::rbd::SnapshotNamespace in_snap_namespace,
267 std::string in_snap_name,
268 librados::snap_t id);
269 uint64_t get_image_size(librados::snap_t in_snap_id) const;
270 uint64_t get_object_count(librados::snap_t in_snap_id) const;
271 bool test_features(uint64_t test_features) const;
272 bool test_features(uint64_t test_features,
273 const RWLock &in_snap_lock) const;
274 int get_flags(librados::snap_t in_snap_id, uint64_t *flags) const;
275 int test_flags(uint64_t test_flags, bool *flags_set) const;
276 int test_flags(uint64_t test_flags, const RWLock &in_snap_lock,
277 bool *flags_set) const;
278 int update_flags(librados::snap_t in_snap_id, uint64_t flag, bool enabled);
280 const ParentInfo* get_parent_info(librados::snap_t in_snap_id) const;
281 int64_t get_parent_pool_id(librados::snap_t in_snap_id) const;
282 std::string get_parent_image_id(librados::snap_t in_snap_id) const;
283 uint64_t get_parent_snap_id(librados::snap_t in_snap_id) const;
284 int get_parent_overlap(librados::snap_t in_snap_id,
285 uint64_t *overlap) const;
286 void aio_read_from_cache(object_t o, uint64_t object_no, bufferlist *bl,
287 size_t len, uint64_t off, Context *onfinish,
288 int fadvise_flags, ZTracer::Trace *trace);
289 void write_to_cache(object_t o, const bufferlist& bl, size_t len,
290 uint64_t off, Context *onfinish, int fadvise_flags,
291 uint64_t journal_tid, ZTracer::Trace *trace);
293 void flush_cache(Context *onfinish);
294 void shut_down_cache(Context *on_finish);
295 int invalidate_cache(bool purge_on_error);
296 void invalidate_cache(bool purge_on_error, Context *on_finish);
297 void clear_nonexistence_cache();
298 bool is_cache_empty();
299 void register_watch(Context *on_finish);
300 uint64_t prune_parent_extents(vector<pair<uint64_t,uint64_t> >& objectx,
303 void flush_async_operations();
304 void flush_async_operations(Context *on_finish);
307 void flush(Context *on_safe);
309 void cancel_async_requests();
310 void cancel_async_requests(Context *on_finish);
312 void apply_metadata(const std::map<std::string, bufferlist> &meta);
314 ExclusiveLock<ImageCtx> *create_exclusive_lock();
315 ObjectMap<ImageCtx> *create_object_map(uint64_t snap_id);
316 Journal<ImageCtx> *create_journal();
318 void clear_pending_completions();
320 void set_image_name(const std::string &name);
322 void notify_update();
323 void notify_update(Context *on_finish);
325 exclusive_lock::Policy *get_exclusive_lock_policy() const;
326 void set_exclusive_lock_policy(exclusive_lock::Policy *policy);
328 journal::Policy *get_journal_policy() const;
329 void set_journal_policy(journal::Policy *policy);
331 static void get_thread_pool_instance(CephContext *cct,
332 ThreadPool **thread_pool,
333 ContextWQ **op_work_queue);
334 static void get_timer_instance(CephContext *cct, SafeTimer **timer,