[ceph.git] / ceph / src / librbd / image / RefreshRequest.h

// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab

#ifndef CEPH_LIBRBD_IMAGE_REFRESH_REQUEST_H
#define CEPH_LIBRBD_IMAGE_REFRESH_REQUEST_H

#include "include/int_types.h"
#include "include/buffer.h"
#include "include/utime.h"
#include "common/snap_types.h"
#include "cls/lock/cls_lock_types.h"
#include "librbd/ImageCtx.h"
#include "librbd/Types.h"
#include <string>
#include <vector>

class Context;

namespace librbd {

class ImageCtx;

namespace image {

template<typename> class RefreshParentRequest;

template<typename ImageCtxT = ImageCtx>
class RefreshRequest {
public:
  static RefreshRequest *create(ImageCtxT &image_ctx, bool acquiring_lock,
                                bool skip_open_parent, Context *on_finish) {
    return new RefreshRequest(image_ctx, acquiring_lock, skip_open_parent,
                              on_finish);
  }

  RefreshRequest(ImageCtxT &image_ctx, bool acquiring_lock,
                 bool skip_open_parent, Context *on_finish);
  ~RefreshRequest();

  void send();

private:
  /**
   * @verbatim
   *
   * <start> < * * * * * * * * * * * * * * * * * * * * * * * * * * (ENOENT)
   *  ^ |                                                        *
   *  * | (v1)                                                   *
   *  * |-----> V1_READ_HEADER -------------> GET_MIGRATION_HEADER (skip if not
   *  * |                                                     |     migrating)
   *  * | (v2)                                                v
   *  * \-----> V2_GET_MUTABLE_METADATA                   V1_GET_SNAPSHOTS
   *  *             |                                         |
   *  *             |     -EOPNOTSUPP                         v
   *  *             |  * * *                              V1_GET_LOCKS
   *  *             |  *   *                                  |
   *  *             v  v   *                                  v
   *  *         V2_GET_PARENT                              <apply>
   *  *             |                                         |
   *  *             v                                         |
   *  * * * * * GET_MIGRATION_HEADER (skip if not             |
   *  (ENOENT)      |                 migrating)              |
   *                v                                         |
   *            V2_GET_METADATA                               |
   *                |                                         |
   *                v                                         |
   *            V2_GET_POOL_METADATA                          |
   *                |                                         |
   *                v (skip if not enabled)                   |
   *            V2_GET_OP_FEATURES                            |
   *                |                                         |
   *                v                                         |
   *            V2_GET_GROUP                                  |
   *                |                                         |
   *                |     -EOPNOTSUPP                         |
   *                |   * * * *                               |
   *                |   *     *                               |
   *                v   v     *                               |
   *            V2_GET_SNAPSHOTS (skip if no snaps)           |
   *                |                                         |
   *                v                                         |
   *            V2_REFRESH_PARENT (skip if no parent or       |
   *                |              refresh not needed)        |
   *                v                                         |
   *            V2_INIT_EXCLUSIVE_LOCK (skip if lock          |
   *                |                   active or disabled)   |
   *                v                                         |
   *            V2_OPEN_OBJECT_MAP (skip if map               |
   *                |               active or disabled)       |
   *                v                                         |
   *            V2_OPEN_JOURNAL (skip if journal              |
   *                |            active or disabled)          |
   *                v                                         |
   *            V2_BLOCK_WRITES (skip if journal not          |
   *                |            disabled)                    |
   *                v                                         |
   *             <apply>                                      |
   *                |                                         |
   *                v                                         |
   *            V2_FINALIZE_REFRESH_PARENT (skip if refresh   |
   *                |                       not needed)       |
   *  (error)       v                                         |
   *  * * * * > V2_SHUT_DOWN_EXCLUSIVE_LOCK (skip if lock     |
   *                |                      active or enabled) |
   *                v                                         |
   *            V2_CLOSE_JOURNAL (skip if journal inactive    |
   *                |             or enabled)                 |
   *                v                                         |
   *            V2_CLOSE_OBJECT_MAP (skip if map inactive     |
   *                |                or enabled)              |
   *                |                                         |
   *                \-------------------\/--------------------/
   *                                    |
   *                                    v
   *                                  FLUSH (skip if no new
   *                                    |    snapshots)
   *                                    v
   *                                 <finish>
   *
   * @endverbatim
   */

  enum LegacySnapshot {
    LEGACY_SNAPSHOT_DISABLED,
    LEGACY_SNAPSHOT_ENABLED,
    LEGACY_SNAPSHOT_ENABLED_NO_TIMESTAMP
  };

  ImageCtxT &m_image_ctx;
  bool m_acquiring_lock;
  bool m_skip_open_parent_image;
  Context *m_on_finish;

  cls::rbd::MigrationSpec m_migration_spec;
  int m_error_result;
  bool m_flush_aio;
  decltype(m_image_ctx.exclusive_lock) m_exclusive_lock;
  decltype(m_image_ctx.object_map) m_object_map;
  decltype(m_image_ctx.journal) m_journal;
  RefreshParentRequest<ImageCtxT> *m_refresh_parent;

  bufferlist m_out_bl;

  bool m_legacy_parent = false;
  LegacySnapshot m_legacy_snapshot = LEGACY_SNAPSHOT_DISABLED;

  uint8_t m_order = 0;
  uint64_t m_size = 0;
  uint64_t m_features = 0;
  uint64_t m_incompatible_features = 0;
  uint64_t m_flags = 0;
  uint64_t m_op_features = 0;
  uint32_t m_read_only_flags = 0U;
  bool m_read_only = false;

  librados::IoCtx m_pool_metadata_io_ctx;
  std::map<std::string, bufferlist> m_metadata;

  std::string m_object_prefix;
  ParentImageInfo m_parent_md;
  bool m_head_parent_overlap = false;
  cls::rbd::GroupSpec m_group_spec;

  ::SnapContext m_snapc;
  std::vector<cls::rbd::SnapshotInfo> m_snap_infos;
  std::vector<ParentImageInfo> m_snap_parents;
  std::vector<uint8_t> m_snap_protection;
  std::vector<uint64_t> m_snap_flags;

  std::map<rados::cls::lock::locker_id_t,
           rados::cls::lock::locker_info_t> m_lockers;
  std::string m_lock_tag;
  bool m_exclusive_locked = false;

  bool m_blocked_writes = false;
  bool m_incomplete_update = false;

  void send_get_migration_header();
  Context *handle_get_migration_header(int *result);

  void send_v1_read_header();
  Context *handle_v1_read_header(int *result);

  void send_v1_get_snapshots();
  Context *handle_v1_get_snapshots(int *result);

  void send_v1_get_locks();
  Context *handle_v1_get_locks(int *result);

  void send_v1_apply();
  Context *handle_v1_apply(int *result);

  void send_v2_get_mutable_metadata();
  Context *handle_v2_get_mutable_metadata(int *result);

  void send_v2_get_parent();
  Context *handle_v2_get_parent(int *result);

  void send_v2_get_metadata();
  Context *handle_v2_get_metadata(int *result);

  void send_v2_get_pool_metadata();
  Context *handle_v2_get_pool_metadata(int *result);

  void send_v2_get_op_features();
  Context *handle_v2_get_op_features(int *result);

  void send_v2_get_group();
  Context *handle_v2_get_group(int *result);

  void send_v2_get_snapshots();
  Context *handle_v2_get_snapshots(int *result);

  void send_v2_get_snapshots_legacy();
  Context *handle_v2_get_snapshots_legacy(int *result);

  void send_v2_refresh_parent();
  Context *handle_v2_refresh_parent(int *result);

  void send_v2_init_exclusive_lock();
  Context *handle_v2_init_exclusive_lock(int *result);

  void send_v2_open_journal();
  Context *handle_v2_open_journal(int *result);

  void send_v2_block_writes();
  Context *handle_v2_block_writes(int *result);

  void send_v2_open_object_map();
  Context *handle_v2_open_object_map(int *result);

  void send_v2_apply();
  Context *handle_v2_apply(int *result);

  Context *send_v2_finalize_refresh_parent();
  Context *handle_v2_finalize_refresh_parent(int *result);

  Context *send_v2_shut_down_exclusive_lock();
  Context *handle_v2_shut_down_exclusive_lock(int *result);

  Context *send_v2_close_journal();
  Context *handle_v2_close_journal(int *result);

  Context *send_v2_close_object_map();
  Context *handle_v2_close_object_map(int *result);

  Context *send_flush_aio();
  Context *handle_flush_aio(int *result);

  Context *handle_error(int *result);

  void save_result(int *result) {
    if (m_error_result == 0 && *result < 0) {
      m_error_result = *result;
    }
  }

  void apply();
  int get_parent_info(uint64_t snap_id, ParentImageInfo *parent_md,
                      MigrationInfo *migration_info);
  bool get_migration_info(ParentImageInfo *parent_md,
                          MigrationInfo *migration_info);
};

} // namespace image
} // namespace librbd

extern template class librbd::image::RefreshRequest<librbd::ImageCtx>;

#endif // CEPH_LIBRBD_IMAGE_REFRESH_REQUEST_H
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
	4	#ifndef CEPH_LIBRBD_IMAGE_REFRESH_REQUEST_H
	5	#define CEPH_LIBRBD_IMAGE_REFRESH_REQUEST_H
	6
	7	#include "include/int_types.h"
	8	#include "include/buffer.h"
	9	#include "include/utime.h"
	10	#include "common/snap_types.h"
	11	#include "cls/lock/cls_lock_types.h"
	12	#include "librbd/ImageCtx.h"
	13	#include "librbd/Types.h"
	14	#include <string>
	15	#include <vector>
	16
	17	class Context;
	18
	19	namespace librbd {
	20
	21	class ImageCtx;
	22
	23	namespace image {
	24
	25	template<typename> class RefreshParentRequest;
	26
	27	template<typename ImageCtxT = ImageCtx>
	28	class RefreshRequest {
	29	public:
	30	static RefreshRequest *create(ImageCtxT &image_ctx, bool acquiring_lock,
	31	bool skip_open_parent, Context *on_finish) {
	32	return new RefreshRequest(image_ctx, acquiring_lock, skip_open_parent,
	33	on_finish);
	34	}
	35
	36	RefreshRequest(ImageCtxT &image_ctx, bool acquiring_lock,
	37	bool skip_open_parent, Context *on_finish);
	38	~RefreshRequest();
	39
	40	void send();
	41
	42	private:
	43	/**
	44	* @verbatim
	45	*
11fdf7f2 TL	46	* <start> < * * * * * * * * * * * * * * * * * * * * * * * * * * (ENOENT)
	47	* ^ \| *
	48	* * \| (v1) *
	49	* * \|-----> V1_READ_HEADER -------------> GET_MIGRATION_HEADER (skip if not
	50	* * \| \| migrating)
	51	* * \| (v2) v
	52	* * \-----> V2_GET_MUTABLE_METADATA V1_GET_SNAPSHOTS
	53	* * \| \|
	54	* * \| -EOPNOTSUPP v
	55	* * \| * * * V1_GET_LOCKS
	56	* * \| * * \|
	57	* * v v * v
	58	* * V2_GET_PARENT <apply>
	59	* * \| \|
	60	* * v \|
	61	* * * * * * GET_MIGRATION_HEADER (skip if not \|
	62	* (ENOENT) \| migrating) \|
7c673cae	63	* v \|
b32b8144 FG	64	* V2_GET_METADATA \|
	65	* \| \|
	66	* v \|
11fdf7f2 TL	67	* V2_GET_POOL_METADATA \|
	68	* \| \|
	69	* v (skip if not enabled) \|
	70	* V2_GET_OP_FEATURES \|
7c673cae FG	71	* \| \|
	72	* v \|
	73	* V2_GET_GROUP \|
	74	* \| \|
11fdf7f2 TL	75	* \| -EOPNOTSUPP \|
	76	* \| * * * * \|
	77	* \| * * \|
	78	* v v * \|
7c673cae FG	79	* V2_GET_SNAPSHOTS (skip if no snaps) \|
	80	* \| \|
	81	* v \|
7c673cae FG	82	* V2_REFRESH_PARENT (skip if no parent or \|
	83	* \| refresh not needed) \|
	84	* v \|
	85	* V2_INIT_EXCLUSIVE_LOCK (skip if lock \|
	86	* \| active or disabled) \|
	87	* v \|
	88	* V2_OPEN_OBJECT_MAP (skip if map \|
	89	* \| active or disabled) \|
	90	* v \|
	91	* V2_OPEN_JOURNAL (skip if journal \|
	92	* \| active or disabled) \|
	93	* v \|
	94	* V2_BLOCK_WRITES (skip if journal not \|
	95	* \| disabled) \|
	96	* v \|
	97	* <apply> \|
	98	* \| \|
	99	* v \|
	100	* V2_FINALIZE_REFRESH_PARENT (skip if refresh \|
	101	* \| not needed) \|
	102	* (error) v \|
	103	* * * * * > V2_SHUT_DOWN_EXCLUSIVE_LOCK (skip if lock \|
	104	* \| active or enabled) \|
	105	* v \|
	106	* V2_CLOSE_JOURNAL (skip if journal inactive \|
	107	* \| or enabled) \|
	108	* v \|
	109	* V2_CLOSE_OBJECT_MAP (skip if map inactive \|
	110	* \| or enabled) \|
	111	* \| \|
	112	* \-------------------\/--------------------/
	113	* \|
	114	* v
	115	* FLUSH (skip if no new
	116	* \| snapshots)
	117	* v
	118	* <finish>
	119	*
	120	* @endverbatim
	121	*/
	122
801d1391 TL	123	enum LegacySnapshot {
	124	LEGACY_SNAPSHOT_DISABLED,
	125	LEGACY_SNAPSHOT_ENABLED,
	126	LEGACY_SNAPSHOT_ENABLED_NO_TIMESTAMP
	127	};
	128
7c673cae FG	129	ImageCtxT &m_image_ctx;
	130	bool m_acquiring_lock;
	131	bool m_skip_open_parent_image;
	132	Context *m_on_finish;
	133
11fdf7f2	134	cls::rbd::MigrationSpec m_migration_spec;
7c673cae FG	135	int m_error_result;
	136	bool m_flush_aio;
	137	decltype(m_image_ctx.exclusive_lock) m_exclusive_lock;
	138	decltype(m_image_ctx.object_map) m_object_map;
	139	decltype(m_image_ctx.journal) m_journal;
	140	RefreshParentRequest<ImageCtxT> *m_refresh_parent;
	141
	142	bufferlist m_out_bl;
	143
11fdf7f2	144	bool m_legacy_parent = false;
801d1391	145	LegacySnapshot m_legacy_snapshot = LEGACY_SNAPSHOT_DISABLED;
11fdf7f2 TL	146
	147	uint8_t m_order = 0;
	148	uint64_t m_size = 0;
	149	uint64_t m_features = 0;
	150	uint64_t m_incompatible_features = 0;
	151	uint64_t m_flags = 0;
	152	uint64_t m_op_features = 0;
9f95a23c TL	153	uint32_t m_read_only_flags = 0U;
9f95a23c TL	154	bool m_read_only = false;
b32b8144	155
11fdf7f2	156	librados::IoCtx m_pool_metadata_io_ctx;
b32b8144 FG	157	std::map<std::string, bufferlist> m_metadata;
b32b8144 FG	158
7c673cae	159	std::string m_object_prefix;
11fdf7f2 TL	160	ParentImageInfo m_parent_md;
11fdf7f2 TL	161	bool m_head_parent_overlap = false;
7c673cae FG	162	cls::rbd::GroupSpec m_group_spec;
	163
	164	::SnapContext m_snapc;
11fdf7f2 TL	165	std::vector<cls::rbd::SnapshotInfo> m_snap_infos;
11fdf7f2 TL	166	std::vector<ParentImageInfo> m_snap_parents;
7c673cae FG	167	std::vector<uint8_t> m_snap_protection;
7c673cae FG	168	std::vector<uint64_t> m_snap_flags;
7c673cae FG	169
	170	std::map<rados::cls::lock::locker_id_t,
	171	rados::cls::lock::locker_info_t> m_lockers;
	172	std::string m_lock_tag;
11fdf7f2	173	bool m_exclusive_locked = false;
7c673cae FG	174
	175	bool m_blocked_writes = false;
	176	bool m_incomplete_update = false;
	177
11fdf7f2 TL	178	void send_get_migration_header();
	179	Context handle_get_migration_header(int result);
	180
7c673cae FG	181	void send_v1_read_header();
	182	Context handle_v1_read_header(int result);
	183
	184	void send_v1_get_snapshots();
	185	Context handle_v1_get_snapshots(int result);
	186
	187	void send_v1_get_locks();
	188	Context handle_v1_get_locks(int result);
	189
	190	void send_v1_apply();
	191	Context handle_v1_apply(int result);
	192
	193	void send_v2_get_mutable_metadata();
	194	Context handle_v2_get_mutable_metadata(int result);
	195
11fdf7f2 TL	196	void send_v2_get_parent();
	197	Context handle_v2_get_parent(int result);
	198
b32b8144 FG	199	void send_v2_get_metadata();
	200	Context handle_v2_get_metadata(int result);
	201
11fdf7f2 TL	202	void send_v2_get_pool_metadata();
	203	Context handle_v2_get_pool_metadata(int result);
	204
	205	void send_v2_get_op_features();
	206	Context handle_v2_get_op_features(int result);
7c673cae FG	207
	208	void send_v2_get_group();
	209	Context handle_v2_get_group(int result);
	210
	211	void send_v2_get_snapshots();
	212	Context handle_v2_get_snapshots(int result);
	213
11fdf7f2 TL	214	void send_v2_get_snapshots_legacy();
11fdf7f2 TL	215	Context handle_v2_get_snapshots_legacy(int result);
7c673cae FG	216
	217	void send_v2_refresh_parent();
	218	Context handle_v2_refresh_parent(int result);
	219
	220	void send_v2_init_exclusive_lock();
	221	Context handle_v2_init_exclusive_lock(int result);
	222
	223	void send_v2_open_journal();
	224	Context handle_v2_open_journal(int result);
	225
	226	void send_v2_block_writes();
	227	Context handle_v2_block_writes(int result);
	228
	229	void send_v2_open_object_map();
	230	Context handle_v2_open_object_map(int result);
	231
	232	void send_v2_apply();
	233	Context handle_v2_apply(int result);
	234
	235	Context *send_v2_finalize_refresh_parent();
	236	Context handle_v2_finalize_refresh_parent(int result);
	237
	238	Context *send_v2_shut_down_exclusive_lock();
	239	Context handle_v2_shut_down_exclusive_lock(int result);
	240
	241	Context *send_v2_close_journal();
	242	Context handle_v2_close_journal(int result);
	243
	244	Context *send_v2_close_object_map();
	245	Context handle_v2_close_object_map(int result);
	246
	247	Context *send_flush_aio();
	248	Context handle_flush_aio(int result);
	249
	250	Context handle_error(int result);
	251
	252	void save_result(int *result) {
	253	if (m_error_result == 0 && *result < 0) {
	254	m_error_result = *result;
	255	}
	256	}
	257
	258	void apply();
11fdf7f2 TL	259	int get_parent_info(uint64_t snap_id, ParentImageInfo *parent_md,
	260	MigrationInfo *migration_info);
	261	bool get_migration_info(ParentImageInfo *parent_md,
	262	MigrationInfo *migration_info);
7c673cae FG	263	};
	264
	265	} // namespace image
	266	} // namespace librbd
	267
	268	extern template class librbd::image::RefreshRequest<librbd::ImageCtx>;
	269
	270	#endif // CEPH_LIBRBD_IMAGE_REFRESH_REQUEST_H