[ceph.git] / ceph / src / librbd / ImageCtx.h

// -*- 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 <list>
#include <map>
#include <string>
#include <vector>

#include "common/event_socket.h"
#include "common/Mutex.h"
#include "common/Readahead.h"
#include "common/RWLock.h"
#include "common/snap_types.h"
#include "common/zipkin_trace.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 "osdc/ObjectCacher.h"

#include "cls/rbd/cls_rbd_types.h"
#include "cls/rbd/cls_rbd_client.h"
#include "librbd/AsyncRequest.h"
#include "librbd/Types.h"

class CephContext;
class ContextWQ;
class Finisher;
class PerfCounters;
class ThreadPool;
class SafeTimer;

namespace librbd {

  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;
  class LibrbdWriteback;

  namespace cache { struct ImageCache; }
  namespace exclusive_lock { struct Policy; }
  namespace io {
  class AioCompletion;
  class AsyncOperation;
  template <typename> class ImageRequestWQ;
  class CopyupRequest;
  }
  namespace journal { struct Policy; }

  namespace operation {
  template <typename> class ResizeRequest;
  }

  struct ImageCtx {
    CephContext *cct;
    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<std::pair<cls::rbd::SnapshotNamespace, std::string>, librados::snap_t> snap_ids;
    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;
    bool flush_encountered;

    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;
    IoCtx data_ctx, md_ctx;
    ImageWatcher<ImageCtx> *image_watcher;
    Journal<ImageCtx> *journal;

    /**
     * Lock ordering:
     *
     * owner_lock, md_lock, cache_lock, snap_lock, parent_lock,
     * object_map_lock, async_op_lock
     */
    RWLock owner_lock; // protects exclusive lock leadership updates
    RWLock md_lock; // 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:
                   // flush_encountered
                   // total_bytes_read
                   // exclusive_locked
                   // lock_tag
                   // lockers
    Mutex cache_lock; // used as client_lock for the ObjectCacher
    RWLock snap_lock; // protects snapshot-related member variables,
                      // features (and associated helper classes), and flags
    RWLock parent_lock; // protects parent_md and parent
    RWLock object_map_lock; // protects object map updates and object_map itself
    Mutex async_ops_lock; // protects async_ops and async_requests
    Mutex copyup_list_lock; // protects copyup_waiting_list
    Mutex completed_reqs_lock; // protects completed_reqs

    unsigned extra_read_flags;

    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
    ParentInfo parent_md;
    ImageCtx *parent;
    cls::rbd::GroupSpec group_spec;
    uint64_t stripe_unit, stripe_count;
    uint64_t flags;
    utime_t create_timestamp;

    file_layout_t layout;

    cache::ImageCache *image_cache = nullptr;
    ObjectCacher *object_cacher;
    LibrbdWriteback *writeback_handler;
    ObjectCacher::ObjectSet *object_set;

    Readahead readahead;
    uint64_t total_bytes_read;

    std::map<uint64_t, io::CopyupRequest*> 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::ImageRequestWQ<ImageCtx> *io_work_queue;
    xlist<io::AioCompletion*> completed_reqs;
    EventSocket event_socket;

    ContextWQ *op_work_queue;

    // Configuration
    static const string METADATA_CONF_PREFIX;
    bool non_blocking_aio;
    bool cache;
    bool cache_writethrough_until_flush;
    uint64_t cache_size;
    uint64_t cache_max_dirty;
    uint64_t cache_target_dirty;
    double cache_max_dirty_age;
    uint32_t cache_max_dirty_object;
    bool cache_block_writes_upfront;
    uint32_t concurrent_management_ops;
    bool balance_snap_reads;
    bool localize_snap_reads;
    bool balance_parent_reads;
    bool localize_parent_reads;
    uint32_t readahead_trigger_requests;
    uint64_t readahead_max_bytes;
    uint64_t readahead_disable_after_bytes;
    bool clone_copy_on_read;
    bool blacklist_on_break_lock;
    uint32_t blacklist_expire_seconds;
    uint32_t request_timed_out_seconds;
    bool enable_alloc_hint;
    uint8_t journal_order;
    uint8_t journal_splay_width;
    double journal_commit_age;
    int journal_object_flush_interval;
    uint64_t journal_object_flush_bytes;
    double journal_object_flush_age;
    std::string journal_pool;
    uint32_t journal_max_payload_bytes;
    int journal_max_concurrent_object_sets;
    bool mirroring_resync_after_disconnect;
    int mirroring_replay_delay;
    bool skip_partial_discard;
    bool blkin_trace_all;

    LibrbdAdminSocketHook *asok_hook;

    exclusive_lock::Policy *exclusive_lock_policy = nullptr;
    journal::Policy *journal_policy = nullptr;

    ZTracer::Endpoint trace_endpoint;

    static bool _filter_metadata_confs(const string &prefix, std::map<string, bool> &configs,
                                       const map<string, bufferlist> &pairs, map<string, bufferlist> *res);

    // 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);
    }
    void destroy() {
      delete this;
    }

    /**
     * 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();
    void init();
    void shutdown();
    void init_layout();
    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(cls::rbd::SnapshotNamespace in_snap_namespace,
		 std::string in_snap_name);
    void snap_unset();
    librados::snap_t get_snap_id(cls::rbd::SnapshotNamespace in_snap_namespace,
				 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,
			ParentSpec *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;
    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;

    void add_snap(cls::rbd::SnapshotNamespace in_snap_namespace,
		  std::string in_snap_name,
		  librados::snap_t id,
		  uint64_t in_size, const ParentInfo &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_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 RWLock &in_snap_lock) const;
    int get_flags(librados::snap_t in_snap_id, uint64_t *flags) const;
    int test_flags(uint64_t test_flags, bool *flags_set) const;
    int test_flags(uint64_t test_flags, const RWLock &in_snap_lock,
                   bool *flags_set) const;
    int update_flags(librados::snap_t in_snap_id, uint64_t flag, bool enabled);

    const ParentInfo* 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 *overlap) const;
    void aio_read_from_cache(object_t o, uint64_t object_no, bufferlist *bl,
			     size_t len, uint64_t off, Context *onfinish,
			     int fadvise_flags, ZTracer::Trace *trace);
    void write_to_cache(object_t o, const bufferlist& bl, size_t len,
			uint64_t off, Context *onfinish, int fadvise_flags,
                        uint64_t journal_tid, ZTracer::Trace *trace);
    void user_flushed();
    void flush_cache(Context *onfinish);
    void shut_down_cache(Context *on_finish);
    int invalidate_cache(bool purge_on_error);
    void invalidate_cache(bool purge_on_error, Context *on_finish);
    void clear_nonexistence_cache();
    bool is_cache_empty();
    void register_watch(Context *on_finish);
    uint64_t prune_parent_extents(vector<pair<uint64_t,uint64_t> >& objectx,
				  uint64_t overlap);

    void flush_async_operations();
    void flush_async_operations(Context *on_finish);

    int flush();
    void flush(Context *on_safe);

    void cancel_async_requests();
    void cancel_async_requests(Context *on_finish);

    void apply_metadata(const std::map<std::string, bufferlist> &meta);

    ExclusiveLock<ImageCtx> *create_exclusive_lock();
    ObjectMap<ImageCtx> *create_object_map(uint64_t snap_id);
    Journal<ImageCtx> *create_journal();

    void clear_pending_completions();

    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);

    static void get_thread_pool_instance(CephContext *cct,
                                         ThreadPool **thread_pool,
                                         ContextWQ **op_work_queue);
    static void get_timer_instance(CephContext *cct, SafeTimer **timer,
                                   Mutex **timer_lock);
  };
}

#endif
Commit	Line	Data
7c673cae FG	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"
31f18b77	18	#include "common/zipkin_trace.h"
7c673cae FG	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
7c673cae FG	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;
31f18b77	54	class AsyncOperation;
224ce89b	55	template <typename> class ImageRequestWQ;
7c673cae FG	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;
31f18b77	131	utime_t create_timestamp;
7c673cae FG	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
31f18b77	145	xlist<io::AsyncOperation*> async_ops;
7c673cae FG	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
224ce89b	157	io::ImageRequestWQ<ImageCtx> *io_work_queue;
7c673cae FG	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;
181888fb	199	bool blkin_trace_all;
7c673cae FG	200
	201	LibrbdAdminSocketHook *asok_hook;
	202
	203	exclusive_lock::Policy *exclusive_lock_policy = nullptr;
	204	journal::Policy *journal_policy = nullptr;
	205
31f18b77 FG	206	ZTracer::Endpoint trace_endpoint;
31f18b77 FG	207
7c673cae FG	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;
31f18b77	259	utime_t get_create_timestamp() const;
7c673cae FG	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;
31f18b77 FG	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;
7c673cae FG	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,
31f18b77	288	int fadvise_flags, ZTracer::Trace *trace);
7c673cae FG	289	void write_to_cache(object_t o, const bufferlist& bl, size_t len,
7c673cae FG	290	uint64_t off, Context *onfinish, int fadvise_flags,
31f18b77	291	uint64_t journal_tid, ZTracer::Trace *trace);
7c673cae FG	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