src/ceph/src/librbd/ImageCtx.h

   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
   5
   6 #include "include/int_types.h"
   7
   8 #include <list>
   9 #include <map>
  10 #include <string>
  11 #include <vector>
  12
  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"
  19
  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"
  26
  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"
  31
  32 class CephContext;
  33 class ContextWQ;
  34 class Finisher;
  35 class PerfCounters;
  36 class ThreadPool;
  37 class SafeTimer;
  38
  39 namespace librbd {
  40
  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;
  49
  50   namespace cache { struct ImageCache; }
  51   namespace exclusive_lock { struct Policy; }
  52   namespace io {
  53   class AioCompletion;
  54   class AsyncOperation;
  55   template <typename> class ImageRequestWQ;
  56   class CopyupRequest;
  57   }
  58   namespace journal { struct Policy; }
  59
  60   namespace operation {
  61   template <typename> class ResizeRequest;
  62   }
  63
  64   struct ImageCtx {
  65     CephContext *cct;
  66     PerfCounters *perfcounter;
  67     struct rbd_obj_header_ondisk header;
  68     ::SnapContext snapc;
  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;
  73     uint64_t snap_id;
  74     bool snap_exists; // false if our snap_id was deleted
  75     // whether the image was opened read-only. cannot be changed after opening
  76     bool read_only;
  77     bool flush_encountered;
  78
  79     std::map<rados::cls::lock::locker_id_t,
  80              rados::cls::lock::locker_info_t> lockers;
  81     bool exclusive_locked;
  82     std::string lock_tag;
  83
  84     std::string name;
  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;
  90
  91     /**
  92      * Lock ordering:
  93      *
  94      * owner_lock, md_lock, cache_lock, snap_lock, parent_lock,
  95      * object_map_lock, async_op_lock
  96      */
  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:
 102                    // flush_encountered
 103                    // total_bytes_read
 104                    // exclusive_locked
 105                    // lock_tag
 106                    // lockers
 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
 115
 116     unsigned extra_read_flags;
 117
 118     bool old_format;
 119     uint8_t order;
 120     uint64_t size;
 121     uint64_t features;
 122     std::string object_prefix;
 123     char *format_string;
 124     std::string header_oid;
 125     std::string id; // only used for new-format images
 126     ParentInfo parent_md;
 127     ImageCtx *parent;
 128     cls::rbd::GroupSpec group_spec;
 129     uint64_t stripe_unit, stripe_count;
 130     uint64_t flags;
 131     utime_t create_timestamp;
 132
 133     file_layout_t layout;
 134
 135     cache::ImageCache *image_cache = nullptr;
 136     ObjectCacher *object_cacher;
 137     LibrbdWriteback *writeback_handler;
 138     ObjectCacher::ObjectSet *object_set;
 139
 140     Readahead readahead;
 141     uint64_t total_bytes_read;
 142
 143     std::map<uint64_t, io::CopyupRequest*> copyup_list;
 144
 145     xlist<io::AsyncOperation*> async_ops;
 146     xlist<AsyncRequest<>*> async_requests;
 147     std::list<Context*> async_requests_waiters;
 148
 149     ImageState<ImageCtx> *state;
 150     Operations<ImageCtx> *operations;
 151
 152     ExclusiveLock<ImageCtx> *exclusive_lock;
 153     ObjectMap<ImageCtx> *object_map;
 154
 155     xlist<operation::ResizeRequest<ImageCtx>*> resize_reqs;
 156
 157     io::ImageRequestWQ<ImageCtx> *io_work_queue;
 158     xlist<io::AioCompletion*> completed_reqs;
 159     EventSocket event_socket;
 160
 161     ContextWQ *op_work_queue;
 162
 163     // Configuration
 164     static const string METADATA_CONF_PREFIX;
 165     bool non_blocking_aio;
 166     bool cache;
 167     bool cache_writethrough_until_flush;
 168     uint64_t cache_size;
 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;
 200
 201     LibrbdAdminSocketHook *asok_hook;
 202
 203     exclusive_lock::Policy *exclusive_lock_policy = nullptr;
 204     journal::Policy *journal_policy = nullptr;
 205
 206     ZTracer::Endpoint trace_endpoint;
 207
 208     static bool _filter_metadata_confs(const string &prefix, std::map<string, bool> &configs,
 209                                        const map<string, bufferlist> &pairs, map<string, bufferlist> *res);
 210
 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);
 216     }
 217     void destroy() {
 218       delete this;
 219     }
 220
 221     /**
 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.
 225      */
 226     ImageCtx(const std::string &image_name, const std::string &image_id,
 227              const char *snap, IoCtx& p, bool read_only);
 228     ~ImageCtx();
 229     void init();
 230     void shutdown();
 231     void init_layout();
 232     void perf_start(std::string name);
 233     void perf_stop();
 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);
 238     void snap_unset();
 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;
 252
 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;
 260
 261     void add_snap(cls::rbd::SnapshotNamespace in_snap_namespace,
 262                   std::string in_snap_name,
 263                   librados::snap_t id,
 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);
 279
 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);
 292     void user_flushed();
 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,
 301                                   uint64_t overlap);
 302
 303     void flush_async_operations();
 304     void flush_async_operations(Context *on_finish);
 305
 306     int flush();
 307     void flush(Context *on_safe);
 308
 309     void cancel_async_requests();
 310     void cancel_async_requests(Context *on_finish);
 311
 312     void apply_metadata(const std::map<std::string, bufferlist> &meta);
 313
 314     ExclusiveLock<ImageCtx> *create_exclusive_lock();
 315     ObjectMap<ImageCtx> *create_object_map(uint64_t snap_id);
 316     Journal<ImageCtx> *create_journal();
 317
 318     void clear_pending_completions();
 319
 320     void set_image_name(const std::string &name);
 321
 322     void notify_update();
 323     void notify_update(Context *on_finish);
 324
 325     exclusive_lock::Policy *get_exclusive_lock_policy() const;
 326     void set_exclusive_lock_policy(exclusive_lock::Policy *policy);
 327
 328     journal::Policy *get_journal_policy() const;
 329     void set_journal_policy(journal::Policy *policy);
 330
 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,
 335                                    Mutex **timer_lock);
 336   };
 337 }
 338
 339 #endif