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

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

#include "cls/rbd/cls_rbd_types.h"
#include "include/int_types.h"
#include "include/buffer_fwd.h"
#include "include/encoding.h"
#include "librbd/watcher/Types.h"
#include <iosfwd>
#include <list>
#include <memory>
#include <string>
#include <boost/variant.hpp>

namespace ceph {
class Formatter;
}

namespace librbd {
namespace watch_notify {

using librbd::watcher::ClientId;

WRITE_CLASS_ENCODER(ClientId);

struct AsyncRequestId {
  ClientId client_id;
  uint64_t request_id;

  AsyncRequestId() : request_id() {}
  AsyncRequestId(const ClientId &client_id_, uint64_t request_id_)
    : client_id(client_id_), request_id(request_id_) {}

  void encode(bufferlist& bl) const;
  void decode(bufferlist::const_iterator& it);
  void dump(Formatter *f) const;

  inline bool operator<(const AsyncRequestId &rhs) const {
    if (client_id != rhs.client_id) {
      return client_id < rhs.client_id;
    } else {
      return request_id < rhs.request_id;
    }
  }
  inline bool operator!=(const AsyncRequestId &rhs) const {
    return (client_id != rhs.client_id || request_id != rhs.request_id);
  }
  inline operator bool() const {
    return (*this != AsyncRequestId());
  }
};

enum NotifyOp {
  NOTIFY_OP_ACQUIRED_LOCK      = 0,
  NOTIFY_OP_RELEASED_LOCK      = 1,
  NOTIFY_OP_REQUEST_LOCK       = 2,
  NOTIFY_OP_HEADER_UPDATE      = 3,
  NOTIFY_OP_ASYNC_PROGRESS     = 4,
  NOTIFY_OP_ASYNC_COMPLETE     = 5,
  NOTIFY_OP_FLATTEN            = 6,
  NOTIFY_OP_RESIZE             = 7,
  NOTIFY_OP_SNAP_CREATE        = 8,
  NOTIFY_OP_SNAP_REMOVE        = 9,
  NOTIFY_OP_REBUILD_OBJECT_MAP = 10,
  NOTIFY_OP_SNAP_RENAME        = 11,
  NOTIFY_OP_SNAP_PROTECT       = 12,
  NOTIFY_OP_SNAP_UNPROTECT     = 13,
  NOTIFY_OP_RENAME             = 14,
  NOTIFY_OP_UPDATE_FEATURES    = 15,
  NOTIFY_OP_MIGRATE            = 16,
  NOTIFY_OP_SPARSIFY           = 17,
  NOTIFY_OP_QUIESCE            = 18,
  NOTIFY_OP_UNQUIESCE          = 19,
  NOTIFY_OP_METADATA_UPDATE    = 20,
};

struct Payload {
  virtual ~Payload() {}

  virtual NotifyOp get_notify_op() const = 0;
  virtual bool check_for_refresh() const = 0;

  virtual void encode(bufferlist &bl) const = 0;
  virtual void decode(__u8 version, bufferlist::const_iterator &iter) = 0;
  virtual void dump(Formatter *f) const = 0;
};

struct AcquiredLockPayload : public Payload {
  ClientId client_id;

  AcquiredLockPayload() {}
  AcquiredLockPayload(const ClientId &client_id) : client_id(client_id) {}

  NotifyOp get_notify_op() const override {
    return NOTIFY_OP_ACQUIRED_LOCK;
  }
  bool check_for_refresh() const override {
    return false;
  }

  void encode(bufferlist &bl) const override;
  void decode(__u8 version, bufferlist::const_iterator &iter) override;
  void dump(Formatter *f) const override;
};

struct ReleasedLockPayload : public Payload {
  ClientId client_id;

  ReleasedLockPayload() {}
  ReleasedLockPayload(const ClientId &client_id) : client_id(client_id) {}

  NotifyOp get_notify_op() const override {
    return NOTIFY_OP_RELEASED_LOCK;
  }
  bool check_for_refresh() const override {
    return false;
  }

  void encode(bufferlist &bl) const override;
  void decode(__u8 version, bufferlist::const_iterator &iter) override;
  void dump(Formatter *f) const override;
};

struct RequestLockPayload : public Payload {
  ClientId client_id;
  bool force = false;

  RequestLockPayload() {}
  RequestLockPayload(const ClientId &client_id, bool force)
    : client_id(client_id), force(force) {
  }

  NotifyOp get_notify_op() const override {
    return NOTIFY_OP_REQUEST_LOCK;
  }
  bool check_for_refresh() const override {
    return false;
  }

  void encode(bufferlist &bl) const override;
  void decode(__u8 version, bufferlist::const_iterator &iter) override;
  void dump(Formatter *f) const override;
};

struct HeaderUpdatePayload : public Payload {
  NotifyOp get_notify_op() const override {
    return NOTIFY_OP_HEADER_UPDATE;
  }
  bool check_for_refresh() const override {
    return false;
  }

  void encode(bufferlist &bl) const override;
  void decode(__u8 version, bufferlist::const_iterator &iter) override;
  void dump(Formatter *f) const override;
};

struct AsyncRequestPayloadBase : public Payload {
public:
  AsyncRequestId async_request_id;

  void encode(bufferlist &bl) const override;
  void decode(__u8 version, bufferlist::const_iterator &iter) override;
  void dump(Formatter *f) const override;

protected:
  AsyncRequestPayloadBase() {}
  AsyncRequestPayloadBase(const AsyncRequestId &id) : async_request_id(id) {}
};

struct AsyncProgressPayload : public AsyncRequestPayloadBase {
  uint64_t offset = 0;
  uint64_t total = 0;

  AsyncProgressPayload() {}
  AsyncProgressPayload(const AsyncRequestId &id, uint64_t offset, uint64_t total)
    : AsyncRequestPayloadBase(id), offset(offset), total(total) {}

  NotifyOp get_notify_op() const override {
    return NOTIFY_OP_ASYNC_PROGRESS;
  }
  bool check_for_refresh() const override {
    return false;
  }

  void encode(bufferlist &bl) const override;
  void decode(__u8 version, bufferlist::const_iterator &iter) override;
  void dump(Formatter *f) const override;
};

struct AsyncCompletePayload : public AsyncRequestPayloadBase {
  int result = 0;

  AsyncCompletePayload() {}
  AsyncCompletePayload(const AsyncRequestId &id, int r)
    : AsyncRequestPayloadBase(id), result(r) {}

  NotifyOp get_notify_op() const override {
    return NOTIFY_OP_ASYNC_COMPLETE;
  }
  bool check_for_refresh() const override {
    return false;
  }

  void encode(bufferlist &bl) const override;
  void decode(__u8 version, bufferlist::const_iterator &iter) override;
  void dump(Formatter *f) const override;
};

struct FlattenPayload : public AsyncRequestPayloadBase {
  FlattenPayload() {}
  FlattenPayload(const AsyncRequestId &id) : AsyncRequestPayloadBase(id) {}

  NotifyOp get_notify_op() const override {
    return NOTIFY_OP_FLATTEN;
  }
  bool check_for_refresh() const override {
    return true;
  }
};

struct ResizePayload : public AsyncRequestPayloadBase {
  uint64_t size = 0;
  bool allow_shrink = true;

  ResizePayload() {}
  ResizePayload(const AsyncRequestId &id, uint64_t size, bool allow_shrink)
    : AsyncRequestPayloadBase(id), size(size), allow_shrink(allow_shrink) {}

  NotifyOp get_notify_op() const override {
    return NOTIFY_OP_RESIZE;
  }
  bool check_for_refresh() const override {
    return true;
  }

  void encode(bufferlist &bl) const override;
  void decode(__u8 version, bufferlist::const_iterator &iter) override;
  void dump(Formatter *f) const override;
};

struct SnapPayloadBase : public AsyncRequestPayloadBase {
public:
  cls::rbd::SnapshotNamespace snap_namespace;
  std::string snap_name;

  bool check_for_refresh() const override {
    return true;
  }

  void encode(bufferlist &bl) const override;
  void decode(__u8 version, bufferlist::const_iterator &iter) override;
  void dump(Formatter *f) const override;

protected:
  SnapPayloadBase() {}
  SnapPayloadBase(const AsyncRequestId &id,
                  const cls::rbd::SnapshotNamespace& snap_namespace,
		  const std::string &name)
    : AsyncRequestPayloadBase(id), snap_namespace(snap_namespace),
      snap_name(name) {
  }
};

struct SnapCreatePayload : public SnapPayloadBase {
  uint64_t flags = 0;

  SnapCreatePayload() {}
  SnapCreatePayload(const AsyncRequestId &id,
                    const cls::rbd::SnapshotNamespace &snap_namespace,
		    const std::string &name, uint64_t flags)
    : SnapPayloadBase(id, snap_namespace, name), flags(flags) {
  }

  NotifyOp get_notify_op() const override {
    return NOTIFY_OP_SNAP_CREATE;
  }

  void encode(bufferlist &bl) const override;
  void decode(__u8 version, bufferlist::const_iterator &iter) override;
  void dump(Formatter *f) const override;
};

struct SnapRenamePayload : public SnapPayloadBase {
  uint64_t snap_id = 0;

  SnapRenamePayload() {}
  SnapRenamePayload(const AsyncRequestId &id,
                    const uint64_t &src_snap_id,
		    const std::string &dst_name)
    : SnapPayloadBase(id, cls::rbd::UserSnapshotNamespace(), dst_name),
      snap_id(src_snap_id) {
  }

  NotifyOp get_notify_op() const override {
    return NOTIFY_OP_SNAP_RENAME;
  }

  void encode(bufferlist &bl) const override;
  void decode(__u8 version, bufferlist::const_iterator &iter) override;
  void dump(Formatter *f) const override;
};

struct SnapRemovePayload : public SnapPayloadBase {
  SnapRemovePayload() {}
  SnapRemovePayload(const AsyncRequestId &id,
                    const cls::rbd::SnapshotNamespace& snap_namespace,
		    const std::string &name)
    : SnapPayloadBase(id, snap_namespace, name) {
  }

  NotifyOp get_notify_op() const override {
    return NOTIFY_OP_SNAP_REMOVE;
  }
};

struct SnapProtectPayload : public SnapPayloadBase {
  SnapProtectPayload() {}
  SnapProtectPayload(const AsyncRequestId &id,
                     const cls::rbd::SnapshotNamespace& snap_namespace,
		     const std::string &name)
    : SnapPayloadBase(id, snap_namespace, name) {
  }

  NotifyOp get_notify_op() const override {
    return NOTIFY_OP_SNAP_PROTECT;
  }
};

struct SnapUnprotectPayload : public SnapPayloadBase {
  SnapUnprotectPayload() {}
  SnapUnprotectPayload(const AsyncRequestId &id,
                       const cls::rbd::SnapshotNamespace& snap_namespace,
		       const std::string &name)
    : SnapPayloadBase(id, snap_namespace, name) {
  }

  NotifyOp get_notify_op() const override {
    return NOTIFY_OP_SNAP_UNPROTECT;
  }
};

struct RebuildObjectMapPayload : public AsyncRequestPayloadBase {
  RebuildObjectMapPayload() {}
  RebuildObjectMapPayload(const AsyncRequestId &id)
    : AsyncRequestPayloadBase(id) {}

  NotifyOp get_notify_op() const override {
    return NOTIFY_OP_REBUILD_OBJECT_MAP;
  }
  bool check_for_refresh() const override {
    return true;
  }
};

struct RenamePayload : public AsyncRequestPayloadBase {
  std::string image_name;

  RenamePayload() {}
  RenamePayload(const AsyncRequestId &id, const std::string _image_name)
    : AsyncRequestPayloadBase(id), image_name(_image_name) {
  }

  NotifyOp get_notify_op() const override {
    return NOTIFY_OP_RENAME;
  }
  bool check_for_refresh() const override {
    return true;
  }

  void encode(bufferlist &bl) const;
  void decode(__u8 version, bufferlist::const_iterator &iter);
  void dump(Formatter *f) const;
};

struct UpdateFeaturesPayload : public AsyncRequestPayloadBase {
  uint64_t features = 0;
  bool enabled = false;

  UpdateFeaturesPayload() {}
  UpdateFeaturesPayload(const AsyncRequestId &id, uint64_t features,
                        bool enabled)
    : AsyncRequestPayloadBase(id), features(features), enabled(enabled) {
  }

  NotifyOp get_notify_op() const override {
    return NOTIFY_OP_UPDATE_FEATURES;
  }
  bool check_for_refresh() const override {
    return true;
  }

  void encode(bufferlist &bl) const override;
  void decode(__u8 version, bufferlist::const_iterator &iter) override;
  void dump(Formatter *f) const override;
};

struct MigratePayload : public AsyncRequestPayloadBase {
  MigratePayload() {}
  MigratePayload(const AsyncRequestId &id) : AsyncRequestPayloadBase(id) {}

  NotifyOp get_notify_op() const override {
    return NOTIFY_OP_MIGRATE;
  }
  bool check_for_refresh() const override {
    return true;
  }
};

struct SparsifyPayload : public AsyncRequestPayloadBase {
  uint64_t sparse_size = 0;

  SparsifyPayload() {}
  SparsifyPayload(const AsyncRequestId &id, uint64_t sparse_size)
    : AsyncRequestPayloadBase(id), sparse_size(sparse_size) {
  }

  NotifyOp get_notify_op() const override {
    return NOTIFY_OP_SPARSIFY;
  }
  bool check_for_refresh() const override {
    return true;
  }

  void encode(bufferlist &bl) const override;
  void decode(__u8 version, bufferlist::const_iterator &iter) override;
  void dump(Formatter *f) const override;
};

struct QuiescePayload : public AsyncRequestPayloadBase {
  QuiescePayload() {}
  QuiescePayload(const AsyncRequestId &id) : AsyncRequestPayloadBase(id) {}

  NotifyOp get_notify_op() const override {
    return NOTIFY_OP_QUIESCE;
  }
  bool check_for_refresh() const override {
    return false;
  }
};

struct UnquiescePayload : public AsyncRequestPayloadBase {
  UnquiescePayload() {}
  UnquiescePayload(const AsyncRequestId &id) : AsyncRequestPayloadBase(id) {}

  NotifyOp get_notify_op() const override {
    return NOTIFY_OP_UNQUIESCE;
  }
  bool check_for_refresh() const override {
    return false;
  }
};

struct MetadataUpdatePayload : public AsyncRequestPayloadBase {
  std::string key;
  std::optional<std::string> value;
  MetadataUpdatePayload() {}
  MetadataUpdatePayload(const AsyncRequestId &id, std::string key,
                        std::optional<std::string> value)
    : AsyncRequestPayloadBase(id), key(key), value(value) {
  }

  NotifyOp get_notify_op() const override {
    return NOTIFY_OP_METADATA_UPDATE;
  }
  bool check_for_refresh() const override {
    return false;
  }

  void encode(bufferlist &bl) const;
  void decode(__u8 version, bufferlist::const_iterator &iter);
  void dump(Formatter *f) const;
};

struct UnknownPayload : public Payload {
  NotifyOp get_notify_op() const override {
    return static_cast<NotifyOp>(-1);
  }
  bool check_for_refresh() const override {
    return false;
  }

  void encode(bufferlist &bl) const override;
  void decode(__u8 version, bufferlist::const_iterator &iter) override;
  void dump(Formatter *f) const override;
};

struct NotifyMessage {
  NotifyMessage() : payload(new UnknownPayload()) {}
  NotifyMessage(Payload *payload) : payload(payload) {}

  std::unique_ptr<Payload> payload;

  bool check_for_refresh() const;

  void encode(bufferlist& bl) const;
  void decode(bufferlist::const_iterator& it);
  void dump(Formatter *f) const;
  NotifyOp get_notify_op() const;

  static void generate_test_instances(std::list<NotifyMessage *> &o);
};

struct ResponseMessage {
  ResponseMessage() : result(0) {}
  ResponseMessage(int result_) : result(result_) {}

  int result;

  void encode(bufferlist& bl) const;
  void decode(bufferlist::const_iterator& it);
  void dump(Formatter *f) const;

  static void generate_test_instances(std::list<ResponseMessage *> &o);
};

std::ostream &operator<<(std::ostream &out,
                         const NotifyOp &op);
std::ostream &operator<<(std::ostream &out,
                         const AsyncRequestId &request);

WRITE_CLASS_ENCODER(AsyncRequestId);
WRITE_CLASS_ENCODER(NotifyMessage);
WRITE_CLASS_ENCODER(ResponseMessage);

} // namespace watch_notify
} // namespace librbd


#endif // LIBRBD_WATCH_NOTIFY_TYPES_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	#ifndef LIBRBD_WATCH_NOTIFY_TYPES_H
	4	#define LIBRBD_WATCH_NOTIFY_TYPES_H
	5
	6	#include "cls/rbd/cls_rbd_types.h"
	7	#include "include/int_types.h"
	8	#include "include/buffer_fwd.h"
	9	#include "include/encoding.h"
	10	#include "librbd/watcher/Types.h"
	11	#include <iosfwd>
	12	#include <list>
f67539c2	13	#include <memory>
7c673cae FG	14	#include <string>
	15	#include <boost/variant.hpp>
	16
	17	namespace ceph {
	18	class Formatter;
	19	}
	20
	21	namespace librbd {
	22	namespace watch_notify {
	23
	24	using librbd::watcher::ClientId;
	25
	26	WRITE_CLASS_ENCODER(ClientId);
	27
	28	struct AsyncRequestId {
	29	ClientId client_id;
	30	uint64_t request_id;
	31
	32	AsyncRequestId() : request_id() {}
	33	AsyncRequestId(const ClientId &client_id_, uint64_t request_id_)
	34	: client_id(client_id_), request_id(request_id_) {}
	35
	36	void encode(bufferlist& bl) const;
11fdf7f2	37	void decode(bufferlist::const_iterator& it);
7c673cae FG	38	void dump(Formatter *f) const;
	39
	40	inline bool operator<(const AsyncRequestId &rhs) const {
	41	if (client_id != rhs.client_id) {
	42	return client_id < rhs.client_id;
	43	} else {
	44	return request_id < rhs.request_id;
	45	}
	46	}
	47	inline bool operator!=(const AsyncRequestId &rhs) const {
	48	return (client_id != rhs.client_id \|\| request_id != rhs.request_id);
	49	}
f67539c2 TL	50	inline operator bool() const {
	51	return (*this != AsyncRequestId());
	52	}
7c673cae FG	53	};
	54
	55	enum NotifyOp {
	56	NOTIFY_OP_ACQUIRED_LOCK = 0,
	57	NOTIFY_OP_RELEASED_LOCK = 1,
	58	NOTIFY_OP_REQUEST_LOCK = 2,
	59	NOTIFY_OP_HEADER_UPDATE = 3,
	60	NOTIFY_OP_ASYNC_PROGRESS = 4,
	61	NOTIFY_OP_ASYNC_COMPLETE = 5,
	62	NOTIFY_OP_FLATTEN = 6,
	63	NOTIFY_OP_RESIZE = 7,
	64	NOTIFY_OP_SNAP_CREATE = 8,
	65	NOTIFY_OP_SNAP_REMOVE = 9,
	66	NOTIFY_OP_REBUILD_OBJECT_MAP = 10,
	67	NOTIFY_OP_SNAP_RENAME = 11,
	68	NOTIFY_OP_SNAP_PROTECT = 12,
	69	NOTIFY_OP_SNAP_UNPROTECT = 13,
	70	NOTIFY_OP_RENAME = 14,
	71	NOTIFY_OP_UPDATE_FEATURES = 15,
11fdf7f2 TL	72	NOTIFY_OP_MIGRATE = 16,
11fdf7f2 TL	73	NOTIFY_OP_SPARSIFY = 17,
f67539c2 TL	74	NOTIFY_OP_QUIESCE = 18,
	75	NOTIFY_OP_UNQUIESCE = 19,
	76	NOTIFY_OP_METADATA_UPDATE = 20,
7c673cae FG	77	};
7c673cae FG	78
f67539c2 TL	79	struct Payload {
	80	virtual ~Payload() {}
	81
	82	virtual NotifyOp get_notify_op() const = 0;
	83	virtual bool check_for_refresh() const = 0;
7c673cae	84
f67539c2 TL	85	virtual void encode(bufferlist &bl) const = 0;
	86	virtual void decode(__u8 version, bufferlist::const_iterator &iter) = 0;
	87	virtual void dump(Formatter *f) const = 0;
	88	};
	89
	90	struct AcquiredLockPayload : public Payload {
7c673cae FG	91	ClientId client_id;
	92
	93	AcquiredLockPayload() {}
f67539c2	94	AcquiredLockPayload(const ClientId &client_id) : client_id(client_id) {}
7c673cae	95
f67539c2 TL	96	NotifyOp get_notify_op() const override {
	97	return NOTIFY_OP_ACQUIRED_LOCK;
	98	}
	99	bool check_for_refresh() const override {
	100	return false;
	101	}
7c673cae	102
f67539c2 TL	103	void encode(bufferlist &bl) const override;
	104	void decode(__u8 version, bufferlist::const_iterator &iter) override;
	105	void dump(Formatter *f) const override;
	106	};
7c673cae	107
f67539c2	108	struct ReleasedLockPayload : public Payload {
7c673cae FG	109	ClientId client_id;
	110
	111	ReleasedLockPayload() {}
f67539c2	112	ReleasedLockPayload(const ClientId &client_id) : client_id(client_id) {}
7c673cae	113
f67539c2 TL	114	NotifyOp get_notify_op() const override {
	115	return NOTIFY_OP_RELEASED_LOCK;
	116	}
	117	bool check_for_refresh() const override {
	118	return false;
	119	}
7c673cae	120
f67539c2 TL	121	void encode(bufferlist &bl) const override;
	122	void decode(__u8 version, bufferlist::const_iterator &iter) override;
	123	void dump(Formatter *f) const override;
	124	};
7c673cae	125
f67539c2	126	struct RequestLockPayload : public Payload {
7c673cae FG	127	ClientId client_id;
	128	bool force = false;
	129
	130	RequestLockPayload() {}
f67539c2 TL	131	RequestLockPayload(const ClientId &client_id, bool force)
f67539c2 TL	132	: client_id(client_id), force(force) {
7c673cae FG	133	}
7c673cae FG	134
f67539c2 TL	135	NotifyOp get_notify_op() const override {
	136	return NOTIFY_OP_REQUEST_LOCK;
	137	}
	138	bool check_for_refresh() const override {
	139	return false;
	140	}
	141
	142	void encode(bufferlist &bl) const override;
	143	void decode(__u8 version, bufferlist::const_iterator &iter) override;
	144	void dump(Formatter *f) const override;
7c673cae FG	145	};
7c673cae FG	146
f67539c2 TL	147	struct HeaderUpdatePayload : public Payload {
	148	NotifyOp get_notify_op() const override {
	149	return NOTIFY_OP_HEADER_UPDATE;
	150	}
	151	bool check_for_refresh() const override {
	152	return false;
	153	}
7c673cae	154
f67539c2 TL	155	void encode(bufferlist &bl) const override;
	156	void decode(__u8 version, bufferlist::const_iterator &iter) override;
	157	void dump(Formatter *f) const override;
7c673cae FG	158	};
7c673cae FG	159
f67539c2	160	struct AsyncRequestPayloadBase : public Payload {
7c673cae FG	161	public:
	162	AsyncRequestId async_request_id;
	163
f67539c2 TL	164	void encode(bufferlist &bl) const override;
	165	void decode(__u8 version, bufferlist::const_iterator &iter) override;
	166	void dump(Formatter *f) const override;
7c673cae FG	167
	168	protected:
	169	AsyncRequestPayloadBase() {}
	170	AsyncRequestPayloadBase(const AsyncRequestId &id) : async_request_id(id) {}
	171	};
	172
	173	struct AsyncProgressPayload : public AsyncRequestPayloadBase {
f67539c2 TL	174	uint64_t offset = 0;
f67539c2 TL	175	uint64_t total = 0;
7c673cae	176
f67539c2 TL	177	AsyncProgressPayload() {}
	178	AsyncProgressPayload(const AsyncRequestId &id, uint64_t offset, uint64_t total)
	179	: AsyncRequestPayloadBase(id), offset(offset), total(total) {}
7c673cae	180
f67539c2 TL	181	NotifyOp get_notify_op() const override {
	182	return NOTIFY_OP_ASYNC_PROGRESS;
	183	}
	184	bool check_for_refresh() const override {
	185	return false;
	186	}
7c673cae	187
f67539c2 TL	188	void encode(bufferlist &bl) const override;
	189	void decode(__u8 version, bufferlist::const_iterator &iter) override;
	190	void dump(Formatter *f) const override;
7c673cae FG	191	};
	192
	193	struct AsyncCompletePayload : public AsyncRequestPayloadBase {
f67539c2	194	int result = 0;
7c673cae	195
f67539c2	196	AsyncCompletePayload() {}
7c673cae FG	197	AsyncCompletePayload(const AsyncRequestId &id, int r)
	198	: AsyncRequestPayloadBase(id), result(r) {}
	199
f67539c2 TL	200	NotifyOp get_notify_op() const override {
	201	return NOTIFY_OP_ASYNC_COMPLETE;
	202	}
	203	bool check_for_refresh() const override {
	204	return false;
	205	}
7c673cae	206
f67539c2 TL	207	void encode(bufferlist &bl) const override;
	208	void decode(__u8 version, bufferlist::const_iterator &iter) override;
	209	void dump(Formatter *f) const override;
7c673cae FG	210	};
	211
	212	struct FlattenPayload : public AsyncRequestPayloadBase {
7c673cae FG	213	FlattenPayload() {}
7c673cae FG	214	FlattenPayload(const AsyncRequestId &id) : AsyncRequestPayloadBase(id) {}
f67539c2 TL	215
	216	NotifyOp get_notify_op() const override {
	217	return NOTIFY_OP_FLATTEN;
	218	}
	219	bool check_for_refresh() const override {
	220	return true;
	221	}
7c673cae FG	222	};
	223
	224	struct ResizePayload : public AsyncRequestPayloadBase {
f67539c2 TL	225	uint64_t size = 0;
f67539c2 TL	226	bool allow_shrink = true;
7c673cae	227
f67539c2 TL	228	ResizePayload() {}
	229	ResizePayload(const AsyncRequestId &id, uint64_t size, bool allow_shrink)
	230	: AsyncRequestPayloadBase(id), size(size), allow_shrink(allow_shrink) {}
7c673cae	231
f67539c2 TL	232	NotifyOp get_notify_op() const override {
	233	return NOTIFY_OP_RESIZE;
	234	}
	235	bool check_for_refresh() const override {
	236	return true;
	237	}
7c673cae	238
f67539c2 TL	239	void encode(bufferlist &bl) const override;
	240	void decode(__u8 version, bufferlist::const_iterator &iter) override;
	241	void dump(Formatter *f) const override;
7c673cae FG	242	};
7c673cae FG	243
f67539c2	244	struct SnapPayloadBase : public AsyncRequestPayloadBase {
7c673cae	245	public:
7c673cae FG	246	cls::rbd::SnapshotNamespace snap_namespace;
	247	std::string snap_name;
	248
f67539c2 TL	249	bool check_for_refresh() const override {
	250	return true;
	251	}
	252
	253	void encode(bufferlist &bl) const override;
	254	void decode(__u8 version, bufferlist::const_iterator &iter) override;
	255	void dump(Formatter *f) const override;
7c673cae FG	256
	257	protected:
	258	SnapPayloadBase() {}
f67539c2 TL	259	SnapPayloadBase(const AsyncRequestId &id,
f67539c2 TL	260	const cls::rbd::SnapshotNamespace& snap_namespace,
7c673cae	261	const std::string &name)
f67539c2 TL	262	: AsyncRequestPayloadBase(id), snap_namespace(snap_namespace),
	263	snap_name(name) {
	264	}
7c673cae FG	265	};
	266
	267	struct SnapCreatePayload : public SnapPayloadBase {
f67539c2	268	uint64_t flags = 0;
7c673cae FG	269
7c673cae FG	270	SnapCreatePayload() {}
f67539c2 TL	271	SnapCreatePayload(const AsyncRequestId &id,
	272	const cls::rbd::SnapshotNamespace &snap_namespace,
	273	const std::string &name, uint64_t flags)
	274	: SnapPayloadBase(id, snap_namespace, name), flags(flags) {
	275	}
7c673cae	276
f67539c2 TL	277	NotifyOp get_notify_op() const override {
	278	return NOTIFY_OP_SNAP_CREATE;
	279	}
	280
	281	void encode(bufferlist &bl) const override;
	282	void decode(__u8 version, bufferlist::const_iterator &iter) override;
	283	void dump(Formatter *f) const override;
7c673cae FG	284	};
	285
	286	struct SnapRenamePayload : public SnapPayloadBase {
f67539c2	287	uint64_t snap_id = 0;
7c673cae FG	288
7c673cae FG	289	SnapRenamePayload() {}
f67539c2 TL	290	SnapRenamePayload(const AsyncRequestId &id,
f67539c2 TL	291	const uint64_t &src_snap_id,
7c673cae	292	const std::string &dst_name)
f67539c2 TL	293	: SnapPayloadBase(id, cls::rbd::UserSnapshotNamespace(), dst_name),
	294	snap_id(src_snap_id) {
	295	}
7c673cae	296
f67539c2 TL	297	NotifyOp get_notify_op() const override {
	298	return NOTIFY_OP_SNAP_RENAME;
	299	}
7c673cae	300
f67539c2 TL	301	void encode(bufferlist &bl) const override;
	302	void decode(__u8 version, bufferlist::const_iterator &iter) override;
	303	void dump(Formatter *f) const override;
7c673cae FG	304	};
	305
	306	struct SnapRemovePayload : public SnapPayloadBase {
7c673cae	307	SnapRemovePayload() {}
f67539c2 TL	308	SnapRemovePayload(const AsyncRequestId &id,
f67539c2 TL	309	const cls::rbd::SnapshotNamespace& snap_namespace,
7c673cae	310	const std::string &name)
f67539c2 TL	311	: SnapPayloadBase(id, snap_namespace, name) {
	312	}
	313
	314	NotifyOp get_notify_op() const override {
	315	return NOTIFY_OP_SNAP_REMOVE;
	316	}
7c673cae FG	317	};
	318
	319	struct SnapProtectPayload : public SnapPayloadBase {
7c673cae	320	SnapProtectPayload() {}
f67539c2 TL	321	SnapProtectPayload(const AsyncRequestId &id,
f67539c2 TL	322	const cls::rbd::SnapshotNamespace& snap_namespace,
7c673cae	323	const std::string &name)
f67539c2 TL	324	: SnapPayloadBase(id, snap_namespace, name) {
	325	}
	326
	327	NotifyOp get_notify_op() const override {
	328	return NOTIFY_OP_SNAP_PROTECT;
	329	}
7c673cae FG	330	};
	331
	332	struct SnapUnprotectPayload : public SnapPayloadBase {
7c673cae	333	SnapUnprotectPayload() {}
f67539c2 TL	334	SnapUnprotectPayload(const AsyncRequestId &id,
f67539c2 TL	335	const cls::rbd::SnapshotNamespace& snap_namespace,
7c673cae	336	const std::string &name)
f67539c2 TL	337	: SnapPayloadBase(id, snap_namespace, name) {
	338	}
	339
	340	NotifyOp get_notify_op() const override {
	341	return NOTIFY_OP_SNAP_UNPROTECT;
	342	}
7c673cae FG	343	};
	344
	345	struct RebuildObjectMapPayload : public AsyncRequestPayloadBase {
7c673cae FG	346	RebuildObjectMapPayload() {}
	347	RebuildObjectMapPayload(const AsyncRequestId &id)
	348	: AsyncRequestPayloadBase(id) {}
f67539c2 TL	349
	350	NotifyOp get_notify_op() const override {
	351	return NOTIFY_OP_REBUILD_OBJECT_MAP;
	352	}
	353	bool check_for_refresh() const override {
	354	return true;
	355	}
7c673cae FG	356	};
7c673cae FG	357
f67539c2 TL	358	struct RenamePayload : public AsyncRequestPayloadBase {
f67539c2 TL	359	std::string image_name;
7c673cae FG	360
7c673cae FG	361	RenamePayload() {}
f67539c2 TL	362	RenamePayload(const AsyncRequestId &id, const std::string _image_name)
	363	: AsyncRequestPayloadBase(id), image_name(_image_name) {
	364	}
7c673cae	365
f67539c2 TL	366	NotifyOp get_notify_op() const override {
	367	return NOTIFY_OP_RENAME;
	368	}
	369	bool check_for_refresh() const override {
	370	return true;
	371	}
7c673cae FG	372
7c673cae FG	373	void encode(bufferlist &bl) const;
11fdf7f2	374	void decode(__u8 version, bufferlist::const_iterator &iter);
7c673cae FG	375	void dump(Formatter *f) const;
	376	};
	377
f67539c2 TL	378	struct UpdateFeaturesPayload : public AsyncRequestPayloadBase {
	379	uint64_t features = 0;
	380	bool enabled = false;
7c673cae	381
f67539c2 TL	382	UpdateFeaturesPayload() {}
	383	UpdateFeaturesPayload(const AsyncRequestId &id, uint64_t features,
	384	bool enabled)
	385	: AsyncRequestPayloadBase(id), features(features), enabled(enabled) {
	386	}
7c673cae	387
f67539c2 TL	388	NotifyOp get_notify_op() const override {
	389	return NOTIFY_OP_UPDATE_FEATURES;
	390	}
	391	bool check_for_refresh() const override {
	392	return true;
	393	}
7c673cae	394
f67539c2 TL	395	void encode(bufferlist &bl) const override;
	396	void decode(__u8 version, bufferlist::const_iterator &iter) override;
	397	void dump(Formatter *f) const override;
11fdf7f2 TL	398	};
	399
	400	struct MigratePayload : public AsyncRequestPayloadBase {
11fdf7f2 TL	401	MigratePayload() {}
11fdf7f2 TL	402	MigratePayload(const AsyncRequestId &id) : AsyncRequestPayloadBase(id) {}
f67539c2 TL	403
	404	NotifyOp get_notify_op() const override {
	405	return NOTIFY_OP_MIGRATE;
	406	}
	407	bool check_for_refresh() const override {
	408	return true;
	409	}
11fdf7f2 TL	410	};
	411
	412	struct SparsifyPayload : public AsyncRequestPayloadBase {
20effc67	413	uint64_t sparse_size = 0;
11fdf7f2 TL	414
11fdf7f2 TL	415	SparsifyPayload() {}
20effc67	416	SparsifyPayload(const AsyncRequestId &id, uint64_t sparse_size)
f67539c2 TL	417	: AsyncRequestPayloadBase(id), sparse_size(sparse_size) {
f67539c2 TL	418	}
11fdf7f2	419
f67539c2 TL	420	NotifyOp get_notify_op() const override {
	421	return NOTIFY_OP_SPARSIFY;
	422	}
	423	bool check_for_refresh() const override {
	424	return true;
	425	}
11fdf7f2	426
f67539c2 TL	427	void encode(bufferlist &bl) const override;
	428	void decode(__u8 version, bufferlist::const_iterator &iter) override;
	429	void dump(Formatter *f) const override;
	430	};
	431
	432	struct QuiescePayload : public AsyncRequestPayloadBase {
	433	QuiescePayload() {}
	434	QuiescePayload(const AsyncRequestId &id) : AsyncRequestPayloadBase(id) {}
	435
	436	NotifyOp get_notify_op() const override {
	437	return NOTIFY_OP_QUIESCE;
	438	}
	439	bool check_for_refresh() const override {
	440	return false;
	441	}
	442	};
	443
	444	struct UnquiescePayload : public AsyncRequestPayloadBase {
	445	UnquiescePayload() {}
	446	UnquiescePayload(const AsyncRequestId &id) : AsyncRequestPayloadBase(id) {}
	447
	448	NotifyOp get_notify_op() const override {
	449	return NOTIFY_OP_UNQUIESCE;
	450	}
	451	bool check_for_refresh() const override {
	452	return false;
	453	}
7c673cae FG	454	};
7c673cae FG	455
f67539c2 TL	456	struct MetadataUpdatePayload : public AsyncRequestPayloadBase {
	457	std::string key;
	458	std::optional<std::string> value;
	459	MetadataUpdatePayload() {}
	460	MetadataUpdatePayload(const AsyncRequestId &id, std::string key,
	461	std::optional<std::string> value)
	462	: AsyncRequestPayloadBase(id), key(key), value(value) {
	463	}
	464
	465	NotifyOp get_notify_op() const override {
	466	return NOTIFY_OP_METADATA_UPDATE;
	467	}
	468	bool check_for_refresh() const override {
	469	return false;
	470	}
7c673cae FG	471
7c673cae FG	472	void encode(bufferlist &bl) const;
11fdf7f2	473	void decode(__u8 version, bufferlist::const_iterator &iter);
7c673cae FG	474	void dump(Formatter *f) const;
	475	};
	476
f67539c2 TL	477	struct UnknownPayload : public Payload {
	478	NotifyOp get_notify_op() const override {
	479	return static_cast<NotifyOp>(-1);
	480	}
	481	bool check_for_refresh() const override {
	482	return false;
	483	}
	484
	485	void encode(bufferlist &bl) const override;
	486	void decode(__u8 version, bufferlist::const_iterator &iter) override;
	487	void dump(Formatter *f) const override;
	488	};
7c673cae FG	489
7c673cae FG	490	struct NotifyMessage {
f67539c2 TL	491	NotifyMessage() : payload(new UnknownPayload()) {}
f67539c2 TL	492	NotifyMessage(Payload *payload) : payload(payload) {}
7c673cae	493
f67539c2	494	std::unique_ptr<Payload> payload;
7c673cae FG	495
	496	bool check_for_refresh() const;
	497
	498	void encode(bufferlist& bl) const;
11fdf7f2	499	void decode(bufferlist::const_iterator& it);
7c673cae	500	void dump(Formatter *f) const;
11fdf7f2	501	NotifyOp get_notify_op() const;
7c673cae FG	502
	503	static void generate_test_instances(std::list<NotifyMessage *> &o);
	504	};
	505
	506	struct ResponseMessage {
	507	ResponseMessage() : result(0) {}
	508	ResponseMessage(int result_) : result(result_) {}
	509
	510	int result;
	511
	512	void encode(bufferlist& bl) const;
11fdf7f2	513	void decode(bufferlist::const_iterator& it);
7c673cae FG	514	void dump(Formatter *f) const;
	515
	516	static void generate_test_instances(std::list<ResponseMessage *> &o);
	517	};
	518
7c673cae	519	std::ostream &operator<<(std::ostream &out,
11fdf7f2	520	const NotifyOp &op);
7c673cae	521	std::ostream &operator<<(std::ostream &out,
11fdf7f2 TL	522	const AsyncRequestId &request);
	523
	524	WRITE_CLASS_ENCODER(AsyncRequestId);
	525	WRITE_CLASS_ENCODER(NotifyMessage);
	526	WRITE_CLASS_ENCODER(ResponseMessage);
	527
	528	} // namespace watch_notify
	529	} // namespace librbd
7c673cae	530
7c673cae FG	531
7c673cae FG	532	#endif // LIBRBD_WATCH_NOTIFY_TYPES_H