diff options
Diffstat (limited to '')
| -rw-r--r-- | src/librbd/WatchNotifyTypes.cc | 557 |
1 files changed, 557 insertions, 0 deletions
diff --git a/src/librbd/WatchNotifyTypes.cc b/src/librbd/WatchNotifyTypes.cc new file mode 100644 index 000000000..413983f3e --- /dev/null +++ b/src/librbd/WatchNotifyTypes.cc @@ -0,0 +1,557 @@ +// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*- +// vim: ts=8 sw=2 smarttab + +#include "cls/rbd/cls_rbd_types.h" +#include "common/Formatter.h" +#include "include/ceph_assert.h" +#include "include/stringify.h" +#include "librbd/WatchNotifyTypes.h" + +namespace librbd { +namespace watch_notify { + +void AsyncRequestId::encode(bufferlist &bl) const { + using ceph::encode; + encode(client_id, bl); + encode(request_id, bl); +} + +void AsyncRequestId::decode(bufferlist::const_iterator &iter) { + using ceph::decode; + decode(client_id, iter); + decode(request_id, iter); +} + +void AsyncRequestId::dump(Formatter *f) const { + f->open_object_section("client_id"); + client_id.dump(f); + f->close_section(); + f->dump_unsigned("request_id", request_id); +} + +void AcquiredLockPayload::encode(bufferlist &bl) const { + using ceph::encode; + encode(client_id, bl); +} + +void AcquiredLockPayload::decode(__u8 version, bufferlist::const_iterator &iter) { + using ceph::decode; + if (version >= 2) { + decode(client_id, iter); + } +} + +void AcquiredLockPayload::dump(Formatter *f) const { + f->open_object_section("client_id"); + client_id.dump(f); + f->close_section(); +} + +void ReleasedLockPayload::encode(bufferlist &bl) const { + using ceph::encode; + encode(client_id, bl); +} + +void ReleasedLockPayload::decode(__u8 version, bufferlist::const_iterator &iter) { + using ceph::decode; + if (version >= 2) { + decode(client_id, iter); + } +} + +void ReleasedLockPayload::dump(Formatter *f) const { + f->open_object_section("client_id"); + client_id.dump(f); + f->close_section(); +} + +void RequestLockPayload::encode(bufferlist &bl) const { + using ceph::encode; + encode(client_id, bl); + encode(force, bl); +} + +void RequestLockPayload::decode(__u8 version, bufferlist::const_iterator &iter) { + using ceph::decode; + if (version >= 2) { + decode(client_id, iter); + } + if (version >= 3) { + decode(force, iter); + } +} + +void RequestLockPayload::dump(Formatter *f) const { + f->open_object_section("client_id"); + client_id.dump(f); + f->close_section(); + f->dump_bool("force", force); +} + +void HeaderUpdatePayload::encode(bufferlist &bl) const { +} + +void HeaderUpdatePayload::decode(__u8 version, bufferlist::const_iterator &iter) { +} + +void HeaderUpdatePayload::dump(Formatter *f) const { +} + +void AsyncRequestPayloadBase::encode(bufferlist &bl) const { + using ceph::encode; + encode(async_request_id, bl); +} + +void AsyncRequestPayloadBase::decode(__u8 version, bufferlist::const_iterator &iter) { + using ceph::decode; + decode(async_request_id, iter); +} + +void AsyncRequestPayloadBase::dump(Formatter *f) const { + f->open_object_section("async_request_id"); + async_request_id.dump(f); + f->close_section(); +} + +void AsyncProgressPayload::encode(bufferlist &bl) const { + using ceph::encode; + AsyncRequestPayloadBase::encode(bl); + encode(offset, bl); + encode(total, bl); +} + +void AsyncProgressPayload::decode(__u8 version, bufferlist::const_iterator &iter) { + using ceph::decode; + AsyncRequestPayloadBase::decode(version, iter); + decode(offset, iter); + decode(total, iter); +} + +void AsyncProgressPayload::dump(Formatter *f) const { + AsyncRequestPayloadBase::dump(f); + f->dump_unsigned("offset", offset); + f->dump_unsigned("total", total); +} + +void AsyncCompletePayload::encode(bufferlist &bl) const { + using ceph::encode; + AsyncRequestPayloadBase::encode(bl); + encode(result, bl); +} + +void AsyncCompletePayload::decode(__u8 version, bufferlist::const_iterator &iter) { + using ceph::decode; + AsyncRequestPayloadBase::decode(version, iter); + decode(result, iter); +} + +void AsyncCompletePayload::dump(Formatter *f) const { + AsyncRequestPayloadBase::dump(f); + f->dump_int("result", result); +} + +void ResizePayload::encode(bufferlist &bl) const { + using ceph::encode; + encode(size, bl); + AsyncRequestPayloadBase::encode(bl); + encode(allow_shrink, bl); +} + +void ResizePayload::decode(__u8 version, bufferlist::const_iterator &iter) { + using ceph::decode; + decode(size, iter); + AsyncRequestPayloadBase::decode(version, iter); + + if (version >= 4) { + decode(allow_shrink, iter); + } +} + +void ResizePayload::dump(Formatter *f) const { + AsyncRequestPayloadBase::dump(f); + f->dump_unsigned("size", size); + f->dump_bool("allow_shrink", allow_shrink); +} + +void SnapPayloadBase::encode(bufferlist &bl) const { + using ceph::encode; + encode(snap_name, bl); + encode(snap_namespace, bl); + encode(async_request_id, bl); +} + +void SnapPayloadBase::decode(__u8 version, bufferlist::const_iterator &iter) { + using ceph::decode; + decode(snap_name, iter); + if (version >= 6) { + decode(snap_namespace, iter); + } + if (version >= 7) { + decode(async_request_id, iter); + } +} + +void SnapPayloadBase::dump(Formatter *f) const { + AsyncRequestPayloadBase::dump(f); + f->dump_string("snap_name", snap_name); + snap_namespace.dump(f); +} + +void SnapCreatePayload::encode(bufferlist &bl) const { + using ceph::encode; + SnapPayloadBase::encode(bl); + encode(flags, bl); +} + +void SnapCreatePayload::decode(__u8 version, bufferlist::const_iterator &iter) { + using ceph::decode; + SnapPayloadBase::decode(version, iter); + if (version == 5) { + decode(snap_namespace, iter); + } + if (version >= 7) { + decode(flags, iter); + } +} + +void SnapCreatePayload::dump(Formatter *f) const { + SnapPayloadBase::dump(f); + f->dump_unsigned("flags", flags); +} + +void SnapRenamePayload::encode(bufferlist &bl) const { + using ceph::encode; + encode(snap_id, bl); + SnapPayloadBase::encode(bl); +} + +void SnapRenamePayload::decode(__u8 version, bufferlist::const_iterator &iter) { + using ceph::decode; + decode(snap_id, iter); + SnapPayloadBase::decode(version, iter); +} + +void SnapRenamePayload::dump(Formatter *f) const { + SnapPayloadBase::dump(f); + f->dump_unsigned("src_snap_id", snap_id); +} + +void RenamePayload::encode(bufferlist &bl) const { + using ceph::encode; + encode(image_name, bl); + encode(async_request_id, bl); +} + +void RenamePayload::decode(__u8 version, bufferlist::const_iterator &iter) { + using ceph::decode; + decode(image_name, iter); + if (version >= 7) { + decode(async_request_id, iter); + } +} + +void RenamePayload::dump(Formatter *f) const { + AsyncRequestPayloadBase::dump(f); + f->dump_string("image_name", image_name); +} + +void UpdateFeaturesPayload::encode(bufferlist &bl) const { + using ceph::encode; + encode(features, bl); + encode(enabled, bl); + encode(async_request_id, bl); +} + +void UpdateFeaturesPayload::decode(__u8 version, bufferlist::const_iterator &iter) { + using ceph::decode; + decode(features, iter); + decode(enabled, iter); + if (version >= 7) { + decode(async_request_id, iter); + } +} + +void UpdateFeaturesPayload::dump(Formatter *f) const { + AsyncRequestPayloadBase::dump(f); + f->dump_unsigned("features", features); + f->dump_bool("enabled", enabled); +} + +void SparsifyPayload::encode(bufferlist &bl) const { + using ceph::encode; + AsyncRequestPayloadBase::encode(bl); + encode(sparse_size, bl); +} + +void SparsifyPayload::decode(__u8 version, bufferlist::const_iterator &iter) { + using ceph::decode; + AsyncRequestPayloadBase::decode(version, iter); + decode(sparse_size, iter); +} + +void SparsifyPayload::dump(Formatter *f) const { + AsyncRequestPayloadBase::dump(f); + f->dump_unsigned("sparse_size", sparse_size); +} + +void MetadataUpdatePayload::encode(bufferlist &bl) const { + using ceph::encode; + encode(key, bl); + encode(value, bl); + encode(async_request_id, bl); +} + +void MetadataUpdatePayload::decode(__u8 version, bufferlist::const_iterator &iter) { + using ceph::decode; + decode(key, iter); + decode(value, iter); + if (version >= 7) { + decode(async_request_id, iter); + } +} + +void MetadataUpdatePayload::dump(Formatter *f) const { + AsyncRequestPayloadBase::dump(f); + f->dump_string("key", key); + f->dump_string("value", *value); +} + +void UnknownPayload::encode(bufferlist &bl) const { + ceph_abort(); +} + +void UnknownPayload::decode(__u8 version, bufferlist::const_iterator &iter) { +} + +void UnknownPayload::dump(Formatter *f) const { +} + +bool NotifyMessage::check_for_refresh() const { + return payload->check_for_refresh(); +} + +void NotifyMessage::encode(bufferlist& bl) const { + ENCODE_START(7, 1, bl); + encode(static_cast<uint32_t>(payload->get_notify_op()), bl); + payload->encode(bl); + ENCODE_FINISH(bl); +} + +void NotifyMessage::decode(bufferlist::const_iterator& iter) { + DECODE_START(1, iter); + + uint32_t notify_op; + decode(notify_op, iter); + + // select the correct payload variant based upon the encoded op + switch (notify_op) { + case NOTIFY_OP_ACQUIRED_LOCK: + payload.reset(new AcquiredLockPayload()); + break; + case NOTIFY_OP_RELEASED_LOCK: + payload.reset(new ReleasedLockPayload()); + break; + case NOTIFY_OP_REQUEST_LOCK: + payload.reset(new RequestLockPayload()); + break; + case NOTIFY_OP_HEADER_UPDATE: + payload.reset(new HeaderUpdatePayload()); + break; + case NOTIFY_OP_ASYNC_PROGRESS: + payload.reset(new AsyncProgressPayload()); + break; + case NOTIFY_OP_ASYNC_COMPLETE: + payload.reset(new AsyncCompletePayload()); + break; + case NOTIFY_OP_FLATTEN: + payload.reset(new FlattenPayload()); + break; + case NOTIFY_OP_RESIZE: + payload.reset(new ResizePayload()); + break; + case NOTIFY_OP_SNAP_CREATE: + payload.reset(new SnapCreatePayload()); + break; + case NOTIFY_OP_SNAP_REMOVE: + payload.reset(new SnapRemovePayload()); + break; + case NOTIFY_OP_SNAP_RENAME: + payload.reset(new SnapRenamePayload()); + break; + case NOTIFY_OP_SNAP_PROTECT: + payload.reset(new SnapProtectPayload()); + break; + case NOTIFY_OP_SNAP_UNPROTECT: + payload.reset(new SnapUnprotectPayload()); + break; + case NOTIFY_OP_REBUILD_OBJECT_MAP: + payload.reset(new RebuildObjectMapPayload()); + break; + case NOTIFY_OP_RENAME: + payload.reset(new RenamePayload()); + break; + case NOTIFY_OP_UPDATE_FEATURES: + payload.reset(new UpdateFeaturesPayload()); + break; + case NOTIFY_OP_MIGRATE: + payload.reset(new MigratePayload()); + break; + case NOTIFY_OP_SPARSIFY: + payload.reset(new SparsifyPayload()); + break; + case NOTIFY_OP_QUIESCE: + payload.reset(new QuiescePayload()); + break; + case NOTIFY_OP_UNQUIESCE: + payload.reset(new UnquiescePayload()); + break; + case NOTIFY_OP_METADATA_UPDATE: + payload.reset(new MetadataUpdatePayload()); + break; + } + + payload->decode(struct_v, iter); + DECODE_FINISH(iter); +} + +void NotifyMessage::dump(Formatter *f) const { + payload->dump(f); +} + +NotifyOp NotifyMessage::get_notify_op() const { + return payload->get_notify_op(); +} + +void NotifyMessage::generate_test_instances(std::list<NotifyMessage *> &o) { + o.push_back(new NotifyMessage(new AcquiredLockPayload(ClientId(1, 2)))); + o.push_back(new NotifyMessage(new ReleasedLockPayload(ClientId(1, 2)))); + o.push_back(new NotifyMessage(new RequestLockPayload(ClientId(1, 2), true))); + o.push_back(new NotifyMessage(new HeaderUpdatePayload())); + o.push_back(new NotifyMessage(new AsyncProgressPayload(AsyncRequestId(ClientId(0, 1), 2), 3, 4))); + o.push_back(new NotifyMessage(new AsyncCompletePayload(AsyncRequestId(ClientId(0, 1), 2), 3))); + o.push_back(new NotifyMessage(new FlattenPayload(AsyncRequestId(ClientId(0, 1), 2)))); + o.push_back(new NotifyMessage(new ResizePayload(AsyncRequestId(ClientId(0, 1), 2), 123, true))); + o.push_back(new NotifyMessage(new SnapCreatePayload(AsyncRequestId(ClientId(0, 1), 2), + cls::rbd::UserSnapshotNamespace(), + "foo", 1))); + o.push_back(new NotifyMessage(new SnapRemovePayload(AsyncRequestId(ClientId(0, 1), 2), + cls::rbd::UserSnapshotNamespace(), "foo"))); + o.push_back(new NotifyMessage(new SnapProtectPayload(AsyncRequestId(ClientId(0, 1), 2), + cls::rbd::UserSnapshotNamespace(), "foo"))); + o.push_back(new NotifyMessage(new SnapUnprotectPayload(AsyncRequestId(ClientId(0, 1), 2), + cls::rbd::UserSnapshotNamespace(), "foo"))); + o.push_back(new NotifyMessage(new RebuildObjectMapPayload(AsyncRequestId(ClientId(0, 1), 2)))); + o.push_back(new NotifyMessage(new RenamePayload(AsyncRequestId(ClientId(0, 1), 2), "foo"))); + o.push_back(new NotifyMessage(new UpdateFeaturesPayload(AsyncRequestId(ClientId(0, 1), 2), + 1, true))); + o.push_back(new NotifyMessage(new MigratePayload(AsyncRequestId(ClientId(0, 1), 2)))); + o.push_back(new NotifyMessage(new SparsifyPayload(AsyncRequestId(ClientId(0, 1), 2), 1))); + o.push_back(new NotifyMessage(new QuiescePayload(AsyncRequestId(ClientId(0, 1), 2)))); + o.push_back(new NotifyMessage(new UnquiescePayload(AsyncRequestId(ClientId(0, 1), 2)))); + o.push_back(new NotifyMessage(new MetadataUpdatePayload(AsyncRequestId(ClientId(0, 1), 2), + "foo", std::optional<std::string>{"xyz"}))); +} + +void ResponseMessage::encode(bufferlist& bl) const { + ENCODE_START(1, 1, bl); + encode(result, bl); + ENCODE_FINISH(bl); +} + +void ResponseMessage::decode(bufferlist::const_iterator& iter) { + DECODE_START(1, iter); + decode(result, iter); + DECODE_FINISH(iter); +} + +void ResponseMessage::dump(Formatter *f) const { + f->dump_int("result", result); +} + +void ResponseMessage::generate_test_instances(std::list<ResponseMessage *> &o) { + o.push_back(new ResponseMessage(1)); +} + +std::ostream &operator<<(std::ostream &out, + const librbd::watch_notify::NotifyOp &op) { + using namespace librbd::watch_notify; + + switch (op) { + case NOTIFY_OP_ACQUIRED_LOCK: + out << "AcquiredLock"; + break; + case NOTIFY_OP_RELEASED_LOCK: + out << "ReleasedLock"; + break; + case NOTIFY_OP_REQUEST_LOCK: + out << "RequestLock"; + break; + case NOTIFY_OP_HEADER_UPDATE: + out << "HeaderUpdate"; + break; + case NOTIFY_OP_ASYNC_PROGRESS: + out << "AsyncProgress"; + break; + case NOTIFY_OP_ASYNC_COMPLETE: + out << "AsyncComplete"; + break; + case NOTIFY_OP_FLATTEN: + out << "Flatten"; + break; + case NOTIFY_OP_RESIZE: + out << "Resize"; + break; + case NOTIFY_OP_SNAP_CREATE: + out << "SnapCreate"; + break; + case NOTIFY_OP_SNAP_REMOVE: + out << "SnapRemove"; + break; + case NOTIFY_OP_SNAP_RENAME: + out << "SnapRename"; + break; + case NOTIFY_OP_SNAP_PROTECT: + out << "SnapProtect"; + break; + case NOTIFY_OP_SNAP_UNPROTECT: + out << "SnapUnprotect"; + break; + case NOTIFY_OP_REBUILD_OBJECT_MAP: + out << "RebuildObjectMap"; + break; + case NOTIFY_OP_RENAME: + out << "Rename"; + break; + case NOTIFY_OP_UPDATE_FEATURES: + out << "UpdateFeatures"; + break; + case NOTIFY_OP_MIGRATE: + out << "Migrate"; + break; + case NOTIFY_OP_SPARSIFY: + out << "Sparsify"; + break; + case NOTIFY_OP_QUIESCE: + out << "Quiesce"; + break; + case NOTIFY_OP_UNQUIESCE: + out << "Unquiesce"; + break; + case NOTIFY_OP_METADATA_UPDATE: + out << "MetadataUpdate"; + break; + default: + out << "Unknown (" << static_cast<uint32_t>(op) << ")"; + break; + } + return out; +} + +std::ostream &operator<<(std::ostream &out, + const librbd::watch_notify::AsyncRequestId &request) { + out << "[" << request.client_id.gid << "," << request.client_id.handle << "," + << request.request_id << "]"; + return out; +} +} // namespace watch_notify +} // namespace librbd |