src/ceph/src/librbd/WatchNotifyTypes.cc

   1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
   2 // vim: ts=8 sw=2 smarttab
   3
   4 #include "cls/rbd/cls_rbd_types.h"
   5 #include "common/Formatter.h"
   6 #include "include/assert.h"
   7 #include "include/stringify.h"
   8 #include "librbd/WatchNotifyTypes.h"
   9 #include "librbd/watcher/Utils.h"
  10
  11 namespace librbd {
  12 namespace watch_notify {
  13
  14 namespace {
  15
  16 class CheckForRefreshVisitor  : public boost::static_visitor<bool> {
  17 public:
  18   template <typename Payload>
  19   inline bool operator()(const Payload &payload) const {
  20     return Payload::CHECK_FOR_REFRESH;
  21   }
  22 };
  23
  24 class DumpPayloadVisitor : public boost::static_visitor<void> {
  25 public:
  26   explicit DumpPayloadVisitor(Formatter *formatter) : m_formatter(formatter) {}
  27
  28   template <typename Payload>
  29   inline void operator()(const Payload &payload) const {
  30     NotifyOp notify_op = Payload::NOTIFY_OP;
  31     m_formatter->dump_string("notify_op", stringify(notify_op));
  32     payload.dump(m_formatter);
  33   }
  34
  35 private:
  36   ceph::Formatter *m_formatter;
  37 };
  38
  39 } // anonymous namespace
  40
  41 void AsyncRequestId::encode(bufferlist &bl) const {
  42   ::encode(client_id, bl);
  43   ::encode(request_id, bl);
  44 }
  45
  46 void AsyncRequestId::decode(bufferlist::iterator &iter) {
  47   ::decode(client_id, iter);
  48   ::decode(request_id, iter);
  49 }
  50
  51 void AsyncRequestId::dump(Formatter *f) const {
  52   f->open_object_section("client_id");
  53   client_id.dump(f);
  54   f->close_section();
  55   f->dump_unsigned("request_id", request_id);
  56 }
  57
  58 void AcquiredLockPayload::encode(bufferlist &bl) const {
  59   ::encode(client_id, bl);
  60 }
  61
  62 void AcquiredLockPayload::decode(__u8 version, bufferlist::iterator &iter) {
  63   if (version >= 2) {
  64     ::decode(client_id, iter);
  65   }
  66 }
  67
  68 void AcquiredLockPayload::dump(Formatter *f) const {
  69   f->open_object_section("client_id");
  70   client_id.dump(f);
  71   f->close_section();
  72 }
  73
  74 void ReleasedLockPayload::encode(bufferlist &bl) const {
  75   ::encode(client_id, bl);
  76 }
  77
  78 void ReleasedLockPayload::decode(__u8 version, bufferlist::iterator &iter) {
  79   if (version >= 2) {
  80     ::decode(client_id, iter);
  81   }
  82 }
  83
  84 void ReleasedLockPayload::dump(Formatter *f) const {
  85   f->open_object_section("client_id");
  86   client_id.dump(f);
  87   f->close_section();
  88 }
  89
  90 void RequestLockPayload::encode(bufferlist &bl) const {
  91   ::encode(client_id, bl);
  92   ::encode(force, bl);
  93 }
  94
  95 void RequestLockPayload::decode(__u8 version, bufferlist::iterator &iter) {
  96   if (version >= 2) {
  97     ::decode(client_id, iter);
  98   }
  99   if (version >= 3) {
 100     ::decode(force, iter);
 101   }
 102 }
 103
 104 void RequestLockPayload::dump(Formatter *f) const {
 105   f->open_object_section("client_id");
 106   client_id.dump(f);
 107   f->close_section();
 108   f->dump_bool("force", force);
 109 }
 110
 111 void HeaderUpdatePayload::encode(bufferlist &bl) const {
 112 }
 113
 114 void HeaderUpdatePayload::decode(__u8 version, bufferlist::iterator &iter) {
 115 }
 116
 117 void HeaderUpdatePayload::dump(Formatter *f) const {
 118 }
 119
 120 void AsyncRequestPayloadBase::encode(bufferlist &bl) const {
 121   ::encode(async_request_id, bl);
 122 }
 123
 124 void AsyncRequestPayloadBase::decode(__u8 version, bufferlist::iterator &iter) {
 125   ::decode(async_request_id, iter);
 126 }
 127
 128 void AsyncRequestPayloadBase::dump(Formatter *f) const {
 129   f->open_object_section("async_request_id");
 130   async_request_id.dump(f);
 131   f->close_section();
 132 }
 133
 134 void AsyncProgressPayload::encode(bufferlist &bl) const {
 135   AsyncRequestPayloadBase::encode(bl);
 136   ::encode(offset, bl);
 137   ::encode(total, bl);
 138 }
 139
 140 void AsyncProgressPayload::decode(__u8 version, bufferlist::iterator &iter) {
 141   AsyncRequestPayloadBase::decode(version, iter);
 142   ::decode(offset, iter);
 143   ::decode(total, iter);
 144 }
 145
 146 void AsyncProgressPayload::dump(Formatter *f) const {
 147   AsyncRequestPayloadBase::dump(f);
 148   f->dump_unsigned("offset", offset);
 149   f->dump_unsigned("total", total);
 150 }
 151
 152 void AsyncCompletePayload::encode(bufferlist &bl) const {
 153   AsyncRequestPayloadBase::encode(bl);
 154   ::encode(result, bl);
 155 }
 156
 157 void AsyncCompletePayload::decode(__u8 version, bufferlist::iterator &iter) {
 158   AsyncRequestPayloadBase::decode(version, iter);
 159   ::decode(result, iter);
 160 }
 161
 162 void AsyncCompletePayload::dump(Formatter *f) const {
 163   AsyncRequestPayloadBase::dump(f);
 164   f->dump_int("result", result);
 165 }
 166
 167 void ResizePayload::encode(bufferlist &bl) const {
 168   ::encode(size, bl);
 169   AsyncRequestPayloadBase::encode(bl);
 170   ::encode(allow_shrink, bl);
 171 }
 172
 173 void ResizePayload::decode(__u8 version, bufferlist::iterator &iter) {
 174   ::decode(size, iter);
 175   AsyncRequestPayloadBase::decode(version, iter);
 176
 177   if (version >= 4) {
 178     ::decode(allow_shrink, iter);
 179   }
 180 }
 181
 182 void ResizePayload::dump(Formatter *f) const {
 183   f->dump_unsigned("size", size);
 184   f->dump_bool("allow_shrink", allow_shrink);
 185   AsyncRequestPayloadBase::dump(f);
 186 }
 187
 188 void SnapPayloadBase::encode(bufferlist &bl) const {
 189   ::encode(snap_name, bl);
 190   ::encode(cls::rbd::SnapshotNamespaceOnDisk(snap_namespace), bl);
 191 }
 192
 193 void SnapPayloadBase::decode(__u8 version, bufferlist::iterator &iter) {
 194   ::decode(snap_name, iter);
 195   if (version >= 6) {
 196     cls::rbd::SnapshotNamespaceOnDisk sn;
 197     ::decode(sn, iter);
 198     snap_namespace = sn.snapshot_namespace;
 199   }
 200 }
 201
 202 void SnapPayloadBase::dump(Formatter *f) const {
 203   f->dump_string("snap_name", snap_name);
 204   cls::rbd::SnapshotNamespaceOnDisk sn(snap_namespace);
 205   sn.dump(f);
 206 }
 207
 208 void SnapCreatePayload::encode(bufferlist &bl) const {
 209   SnapPayloadBase::encode(bl);
 210 }
 211
 212 void SnapCreatePayload::decode(__u8 version, bufferlist::iterator &iter) {
 213   SnapPayloadBase::decode(version, iter);
 214   if (version == 5) {
 215     cls::rbd::SnapshotNamespaceOnDisk sn;
 216     ::decode(sn, iter);
 217     snap_namespace = sn.snapshot_namespace;
 218   }
 219 }
 220
 221 void SnapCreatePayload::dump(Formatter *f) const {
 222   SnapPayloadBase::dump(f);
 223 }
 224
 225 void SnapRenamePayload::encode(bufferlist &bl) const {
 226   ::encode(snap_id, bl);
 227   SnapPayloadBase::encode(bl);
 228 }
 229
 230 void SnapRenamePayload::decode(__u8 version, bufferlist::iterator &iter) {
 231   ::decode(snap_id, iter);
 232   SnapPayloadBase::decode(version, iter);
 233 }
 234
 235 void SnapRenamePayload::dump(Formatter *f) const {
 236   f->dump_unsigned("src_snap_id", snap_id);
 237   SnapPayloadBase::dump(f);
 238 }
 239
 240 void RenamePayload::encode(bufferlist &bl) const {
 241   ::encode(image_name, bl);
 242 }
 243
 244 void RenamePayload::decode(__u8 version, bufferlist::iterator &iter) {
 245   ::decode(image_name, iter);
 246 }
 247
 248 void RenamePayload::dump(Formatter *f) const {
 249   f->dump_string("image_name", image_name);
 250 }
 251
 252 void UpdateFeaturesPayload::encode(bufferlist &bl) const {
 253   ::encode(features, bl);
 254   ::encode(enabled, bl);
 255 }
 256
 257 void UpdateFeaturesPayload::decode(__u8 version, bufferlist::iterator &iter) {
 258   ::decode(features, iter);
 259   ::decode(enabled, iter);
 260 }
 261
 262 void UpdateFeaturesPayload::dump(Formatter *f) const {
 263   f->dump_unsigned("features", features);
 264   f->dump_bool("enabled", enabled);
 265 }
 266
 267 void UnknownPayload::encode(bufferlist &bl) const {
 268   assert(false);
 269 }
 270
 271 void UnknownPayload::decode(__u8 version, bufferlist::iterator &iter) {
 272 }
 273
 274 void UnknownPayload::dump(Formatter *f) const {
 275 }
 276
 277 bool NotifyMessage::check_for_refresh() const {
 278   return boost::apply_visitor(CheckForRefreshVisitor(), payload);
 279 }
 280
 281 void NotifyMessage::encode(bufferlist& bl) const {
 282   ENCODE_START(6, 1, bl);
 283   boost::apply_visitor(watcher::util::EncodePayloadVisitor(bl), payload);
 284   ENCODE_FINISH(bl);
 285 }
 286
 287 void NotifyMessage::decode(bufferlist::iterator& iter) {
 288   DECODE_START(1, iter);
 289
 290   uint32_t notify_op;
 291   ::decode(notify_op, iter);
 292
 293   // select the correct payload variant based upon the encoded op
 294   switch (notify_op) {
 295   case NOTIFY_OP_ACQUIRED_LOCK:
 296     payload = AcquiredLockPayload();
 297     break;
 298   case NOTIFY_OP_RELEASED_LOCK:
 299     payload = ReleasedLockPayload();
 300     break;
 301   case NOTIFY_OP_REQUEST_LOCK:
 302     payload = RequestLockPayload();
 303     break;
 304   case NOTIFY_OP_HEADER_UPDATE:
 305     payload = HeaderUpdatePayload();
 306     break;
 307   case NOTIFY_OP_ASYNC_PROGRESS:
 308     payload = AsyncProgressPayload();
 309     break;
 310   case NOTIFY_OP_ASYNC_COMPLETE:
 311     payload = AsyncCompletePayload();
 312     break;
 313   case NOTIFY_OP_FLATTEN:
 314     payload = FlattenPayload();
 315     break;
 316   case NOTIFY_OP_RESIZE:
 317     payload = ResizePayload();
 318     break;
 319   case NOTIFY_OP_SNAP_CREATE:
 320     payload = SnapCreatePayload();
 321     break;
 322   case NOTIFY_OP_SNAP_REMOVE:
 323     payload = SnapRemovePayload();
 324     break;
 325   case NOTIFY_OP_SNAP_RENAME:
 326     payload = SnapRenamePayload();
 327     break;
 328   case NOTIFY_OP_SNAP_PROTECT:
 329     payload = SnapProtectPayload();
 330     break;
 331   case NOTIFY_OP_SNAP_UNPROTECT:
 332     payload = SnapUnprotectPayload();
 333     break;
 334   case NOTIFY_OP_REBUILD_OBJECT_MAP:
 335     payload = RebuildObjectMapPayload();
 336     break;
 337   case NOTIFY_OP_RENAME:
 338     payload = RenamePayload();
 339     break;
 340   case NOTIFY_OP_UPDATE_FEATURES:
 341     payload = UpdateFeaturesPayload();
 342     break;
 343   default:
 344     payload = UnknownPayload();
 345     break;
 346   }
 347
 348   apply_visitor(watcher::util::DecodePayloadVisitor(struct_v, iter), payload);
 349   DECODE_FINISH(iter);
 350 }
 351
 352 void NotifyMessage::dump(Formatter *f) const {
 353   apply_visitor(DumpPayloadVisitor(f), payload);
 354 }
 355
 356 void NotifyMessage::generate_test_instances(std::list<NotifyMessage *> &o) {
 357   o.push_back(new NotifyMessage(AcquiredLockPayload(ClientId(1, 2))));
 358   o.push_back(new NotifyMessage(ReleasedLockPayload(ClientId(1, 2))));
 359   o.push_back(new NotifyMessage(RequestLockPayload(ClientId(1, 2), true)));
 360   o.push_back(new NotifyMessage(HeaderUpdatePayload()));
 361   o.push_back(new NotifyMessage(AsyncProgressPayload(AsyncRequestId(ClientId(0, 1), 2), 3, 4)));
 362   o.push_back(new NotifyMessage(AsyncCompletePayload(AsyncRequestId(ClientId(0, 1), 2), 3)));
 363   o.push_back(new NotifyMessage(FlattenPayload(AsyncRequestId(ClientId(0, 1), 2))));
 364   o.push_back(new NotifyMessage(ResizePayload(123, true, AsyncRequestId(ClientId(0, 1), 2))));
 365   o.push_back(new NotifyMessage(SnapCreatePayload(cls::rbd::UserSnapshotNamespace(),
 366                                                   "foo")));
 367   o.push_back(new NotifyMessage(SnapRemovePayload(cls::rbd::UserSnapshotNamespace(), "foo")));
 368   o.push_back(new NotifyMessage(SnapProtectPayload(cls::rbd::UserSnapshotNamespace(), "foo")));
 369   o.push_back(new NotifyMessage(SnapUnprotectPayload(cls::rbd::UserSnapshotNamespace(), "foo")));
 370   o.push_back(new NotifyMessage(RebuildObjectMapPayload(AsyncRequestId(ClientId(0, 1), 2))));
 371   o.push_back(new NotifyMessage(RenamePayload("foo")));
 372   o.push_back(new NotifyMessage(UpdateFeaturesPayload(1, true)));
 373 }
 374
 375 void ResponseMessage::encode(bufferlist& bl) const {
 376   ENCODE_START(1, 1, bl);
 377   ::encode(result, bl);
 378   ENCODE_FINISH(bl);
 379 }
 380
 381 void ResponseMessage::decode(bufferlist::iterator& iter) {
 382   DECODE_START(1, iter);
 383   ::decode(result, iter);
 384   DECODE_FINISH(iter);
 385 }
 386
 387 void ResponseMessage::dump(Formatter *f) const {
 388   f->dump_int("result", result);
 389 }
 390
 391 void ResponseMessage::generate_test_instances(std::list<ResponseMessage *> &o) {
 392   o.push_back(new ResponseMessage(1));
 393 }
 394
 395 } // namespace watch_notify
 396 } // namespace librbd
 397
 398 std::ostream &operator<<(std::ostream &out,
 399                          const librbd::watch_notify::NotifyOp &op) {
 400   using namespace librbd::watch_notify;
 401
 402   switch (op) {
 403   case NOTIFY_OP_ACQUIRED_LOCK:
 404     out << "AcquiredLock";
 405     break;
 406   case NOTIFY_OP_RELEASED_LOCK:
 407     out << "ReleasedLock";
 408     break;
 409   case NOTIFY_OP_REQUEST_LOCK:
 410     out << "RequestLock";
 411     break;
 412   case NOTIFY_OP_HEADER_UPDATE:
 413     out << "HeaderUpdate";
 414     break;
 415   case NOTIFY_OP_ASYNC_PROGRESS:
 416     out << "AsyncProgress";
 417     break;
 418   case NOTIFY_OP_ASYNC_COMPLETE:
 419     out << "AsyncComplete";
 420     break;
 421   case NOTIFY_OP_FLATTEN:
 422     out << "Flatten";
 423     break;
 424   case NOTIFY_OP_RESIZE:
 425     out << "Resize";
 426     break;
 427   case NOTIFY_OP_SNAP_CREATE:
 428     out << "SnapCreate";
 429     break;
 430   case NOTIFY_OP_SNAP_REMOVE:
 431     out << "SnapRemove";
 432     break;
 433   case NOTIFY_OP_SNAP_RENAME:
 434     out << "SnapRename";
 435     break;
 436   case NOTIFY_OP_SNAP_PROTECT:
 437     out << "SnapProtect";
 438     break;
 439   case NOTIFY_OP_SNAP_UNPROTECT:
 440     out << "SnapUnprotect";
 441     break;
 442   case NOTIFY_OP_REBUILD_OBJECT_MAP:
 443     out << "RebuildObjectMap";
 444     break;
 445   case NOTIFY_OP_RENAME:
 446     out << "Rename";
 447     break;
 448   case NOTIFY_OP_UPDATE_FEATURES:
 449     out << "UpdateFeatures";
 450     break;
 451   default:
 452     out << "Unknown (" << static_cast<uint32_t>(op) << ")";
 453     break;
 454   }
 455   return out;
 456 }
 457
 458 std::ostream &operator<<(std::ostream &out,
 459                          const librbd::watch_notify::AsyncRequestId &request) {
 460   out << "[" << request.client_id.gid << "," << request.client_id.handle << ","
 461       << request.request_id << "]";
 462   return out;
 463 }