ceph/src/cls/rbd/cls_rbd_types.h

   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_CLS_RBD_TYPES_H
   5 #define CEPH_CLS_RBD_TYPES_H
   6
   7 #include <boost/variant.hpp>
   8 #include "include/int_types.h"
   9 #include "include/buffer.h"
  10 #include "include/encoding.h"
  11 #include "include/stringify.h"
  12 #include "include/utime.h"
  13 #include "msg/msg_types.h"
  14 #include <iosfwd>
  15 #include <string>
  16 #include <set>
  17
  18 #define RBD_GROUP_REF "rbd_group_ref"
  19
  20 namespace ceph { class Formatter; }
  21
  22 namespace cls {
  23 namespace rbd {
  24
  25 static const uint32_t MAX_OBJECT_MAP_OBJECT_COUNT = 256000000;
  26 static const std::string RBD_GROUP_IMAGE_KEY_PREFIX = "image_";
  27
  28 enum DirectoryState {
  29   DIRECTORY_STATE_READY         = 0,
  30   DIRECTORY_STATE_ADD_DISABLED  = 1
  31 };
  32
  33 inline void encode(DirectoryState state, ceph::buffer::list& bl,
  34                    uint64_t features=0)
  35 {
  36   ceph::encode(static_cast<uint8_t>(state), bl);
  37 }
  38
  39 inline void decode(DirectoryState &state, ceph::buffer::list::const_iterator& it)
  40 {
  41   uint8_t int_state;
  42   ceph::decode(int_state, it);
  43   state = static_cast<DirectoryState>(int_state);
  44 }
  45
  46 enum MirrorMode {
  47   MIRROR_MODE_DISABLED = 0,
  48   MIRROR_MODE_IMAGE    = 1,
  49   MIRROR_MODE_POOL     = 2
  50 };
  51
  52 enum GroupImageLinkState {
  53   GROUP_IMAGE_LINK_STATE_ATTACHED,
  54   GROUP_IMAGE_LINK_STATE_INCOMPLETE
  55 };
  56
  57 inline void encode(const GroupImageLinkState &state, ceph::buffer::list& bl,
  58                    uint64_t features=0)
  59 {
  60   using ceph::encode;
  61   encode(static_cast<uint8_t>(state), bl);
  62 }
  63
  64 inline void decode(GroupImageLinkState &state, ceph::buffer::list::const_iterator& it)
  65 {
  66   uint8_t int_state;
  67   using ceph::decode;
  68   decode(int_state, it);
  69   state = static_cast<GroupImageLinkState>(int_state);
  70 }
  71
  72 enum MirrorPeerDirection {
  73   MIRROR_PEER_DIRECTION_RX    = 0,
  74   MIRROR_PEER_DIRECTION_TX    = 1,
  75   MIRROR_PEER_DIRECTION_RX_TX = 2
  76 };
  77
  78 std::ostream& operator<<(std::ostream& os,
  79                          MirrorPeerDirection mirror_peer_direction);
  80
  81 struct MirrorPeer {
  82   MirrorPeer() {
  83   }
  84   MirrorPeer(const std::string &uuid,
  85              MirrorPeerDirection mirror_peer_direction,
  86              const std::string& site_name,
  87              const std::string& client_name,
  88              const std::string& mirror_uuid)
  89     : uuid(uuid), mirror_peer_direction(mirror_peer_direction),
  90       site_name(site_name), client_name(client_name),
  91       mirror_uuid(mirror_uuid) {
  92   }
  93
  94   std::string uuid;
  95
  96   MirrorPeerDirection mirror_peer_direction = MIRROR_PEER_DIRECTION_RX_TX;
  97   std::string site_name;
  98   std::string client_name;  // RX property
  99   std::string mirror_uuid;
 100   utime_t last_seen;
 101
 102   inline bool is_valid() const {
 103     switch (mirror_peer_direction) {
 104     case MIRROR_PEER_DIRECTION_TX:
 105       break;
 106     case MIRROR_PEER_DIRECTION_RX:
 107     case MIRROR_PEER_DIRECTION_RX_TX:
 108       if (client_name.empty()) {
 109         return false;
 110       }
 111       break;
 112     default:
 113       return false;
 114     }
 115     return (!uuid.empty() && !site_name.empty());
 116   }
 117
 118   void encode(ceph::buffer::list &bl) const;
 119   void decode(ceph::buffer::list::const_iterator &it);
 120   void dump(ceph::Formatter *f) const;
 121
 122   static void generate_test_instances(std::list<MirrorPeer*> &o);
 123
 124   bool operator==(const MirrorPeer &rhs) const;
 125   bool operator!=(const MirrorPeer &rhs) const {
 126     return (!(*this == rhs));
 127   }
 128 };
 129
 130 std::ostream& operator<<(std::ostream& os, const MirrorMode& mirror_mode);
 131 std::ostream& operator<<(std::ostream& os, const MirrorPeer& peer);
 132
 133 WRITE_CLASS_ENCODER(MirrorPeer);
 134
 135 enum MirrorImageMode {
 136   MIRROR_IMAGE_MODE_JOURNAL  = 0,
 137   MIRROR_IMAGE_MODE_SNAPSHOT = 1,
 138 };
 139
 140 enum MirrorImageState {
 141   MIRROR_IMAGE_STATE_DISABLING = 0,
 142   MIRROR_IMAGE_STATE_ENABLED   = 1,
 143   MIRROR_IMAGE_STATE_DISABLED  = 2,
 144   MIRROR_IMAGE_STATE_CREATING  = 3,
 145 };
 146
 147 struct MirrorImage {
 148   MirrorImage() {
 149   }
 150   MirrorImage(MirrorImageMode mode, const std::string &global_image_id,
 151               MirrorImageState state)
 152     : mode(mode), global_image_id(global_image_id), state(state) {
 153   }
 154
 155   MirrorImageMode mode = MIRROR_IMAGE_MODE_JOURNAL;
 156   std::string global_image_id;
 157   MirrorImageState state = MIRROR_IMAGE_STATE_DISABLING;
 158
 159   void encode(ceph::buffer::list &bl) const;
 160   void decode(ceph::buffer::list::const_iterator &it);
 161   void dump(ceph::Formatter *f) const;
 162
 163   static void generate_test_instances(std::list<MirrorImage*> &o);
 164
 165   bool operator==(const MirrorImage &rhs) const;
 166   bool operator<(const MirrorImage &rhs) const;
 167 };
 168
 169 std::ostream& operator<<(std::ostream& os, const MirrorImageMode& mirror_mode);
 170 std::ostream& operator<<(std::ostream& os, const MirrorImageState& mirror_state);
 171 std::ostream& operator<<(std::ostream& os, const MirrorImage& mirror_image);
 172
 173 WRITE_CLASS_ENCODER(MirrorImage);
 174
 175 enum MirrorImageStatusState {
 176   MIRROR_IMAGE_STATUS_STATE_UNKNOWN         = 0,
 177   MIRROR_IMAGE_STATUS_STATE_ERROR           = 1,
 178   MIRROR_IMAGE_STATUS_STATE_SYNCING         = 2,
 179   MIRROR_IMAGE_STATUS_STATE_STARTING_REPLAY = 3,
 180   MIRROR_IMAGE_STATUS_STATE_REPLAYING       = 4,
 181   MIRROR_IMAGE_STATUS_STATE_STOPPING_REPLAY = 5,
 182   MIRROR_IMAGE_STATUS_STATE_STOPPED         = 6,
 183 };
 184
 185 inline void encode(const MirrorImageStatusState &state, ceph::buffer::list& bl,
 186                    uint64_t features=0)
 187 {
 188   using ceph::encode;
 189   encode(static_cast<uint8_t>(state), bl);
 190 }
 191
 192 inline void decode(MirrorImageStatusState &state,
 193                    ceph::buffer::list::const_iterator& it)
 194 {
 195   uint8_t int_state;
 196   using ceph::decode;
 197   decode(int_state, it);
 198   state = static_cast<MirrorImageStatusState>(int_state);
 199 }
 200
 201 std::ostream& operator<<(std::ostream& os, const MirrorImageStatusState& state);
 202
 203 struct MirrorImageSiteStatus {
 204   static const std::string LOCAL_MIRROR_UUID;
 205
 206   MirrorImageSiteStatus() {}
 207   MirrorImageSiteStatus(const std::string& mirror_uuid,
 208                         MirrorImageStatusState state,
 209                         const std::string &description)
 210     : mirror_uuid(mirror_uuid), state(state), description(description) {
 211   }
 212
 213   std::string mirror_uuid = LOCAL_MIRROR_UUID;
 214   MirrorImageStatusState state = MIRROR_IMAGE_STATUS_STATE_UNKNOWN;
 215   std::string description;
 216   utime_t last_update;
 217   bool up = false;
 218
 219   void encode_meta(uint8_t version, ceph::buffer::list &bl) const;
 220   void decode_meta(uint8_t version, ceph::buffer::list::const_iterator &it);
 221
 222   void encode(ceph::buffer::list &bl) const;
 223   void decode(ceph::buffer::list::const_iterator &it);
 224   void dump(ceph::Formatter *f) const;
 225
 226   std::string state_to_string() const;
 227
 228   bool operator==(const MirrorImageSiteStatus &rhs) const;
 229
 230   static void generate_test_instances(std::list<MirrorImageSiteStatus*> &o);
 231 };
 232 WRITE_CLASS_ENCODER(MirrorImageSiteStatus);
 233
 234 std::ostream& operator<<(std::ostream& os, const MirrorImageSiteStatus& status);
 235
 236 struct MirrorImageSiteStatusOnDisk : cls::rbd::MirrorImageSiteStatus {
 237   entity_inst_t origin;
 238
 239   MirrorImageSiteStatusOnDisk() {
 240   }
 241   MirrorImageSiteStatusOnDisk(const cls::rbd::MirrorImageSiteStatus &status) :
 242     cls::rbd::MirrorImageSiteStatus(status) {
 243   }
 244
 245   void encode_meta(ceph::buffer::list &bl, uint64_t features) const;
 246   void decode_meta(ceph::buffer::list::const_iterator &it);
 247
 248   void encode(ceph::buffer::list &bl, uint64_t features) const;
 249   void decode(ceph::buffer::list::const_iterator &it);
 250
 251   static void generate_test_instances(
 252       std::list<MirrorImageSiteStatusOnDisk*> &o);
 253 };
 254 WRITE_CLASS_ENCODER_FEATURES(MirrorImageSiteStatusOnDisk)
 255
 256 struct MirrorImageStatus {
 257   typedef std::list<MirrorImageSiteStatus> MirrorImageSiteStatuses;
 258
 259   MirrorImageStatus() {}
 260   MirrorImageStatus(const MirrorImageSiteStatuses& statuses)
 261     : mirror_image_site_statuses(statuses) {
 262   }
 263
 264   MirrorImageSiteStatuses mirror_image_site_statuses;
 265
 266   int get_local_mirror_image_site_status(MirrorImageSiteStatus* status) const;
 267
 268   void encode(ceph::buffer::list &bl) const;
 269   void decode(ceph::buffer::list::const_iterator &it);
 270   void dump(ceph::Formatter *f) const;
 271
 272   bool operator==(const MirrorImageStatus& rhs) const;
 273
 274   static void generate_test_instances(std::list<MirrorImageStatus*> &o);
 275 };
 276 WRITE_CLASS_ENCODER(MirrorImageStatus);
 277
 278 std::ostream& operator<<(std::ostream& os, const MirrorImageStatus& status);
 279
 280 struct ParentImageSpec {
 281   int64_t pool_id = -1;
 282   std::string pool_namespace;
 283   std::string image_id;
 284   snapid_t snap_id = CEPH_NOSNAP;
 285
 286   ParentImageSpec() {
 287   }
 288   ParentImageSpec(int64_t pool_id, const std::string& pool_namespace,
 289                   const std::string& image_id, snapid_t snap_id)
 290     : pool_id(pool_id), pool_namespace(pool_namespace), image_id(image_id),
 291       snap_id(snap_id) {
 292   }
 293
 294   bool exists() const {
 295     return (pool_id >= 0 && !image_id.empty() && snap_id != CEPH_NOSNAP);
 296   }
 297
 298   bool operator==(const ParentImageSpec& rhs) const {
 299     return ((pool_id == rhs.pool_id) &&
 300             (pool_namespace == rhs.pool_namespace) &&
 301             (image_id == rhs.image_id) &&
 302             (snap_id == rhs.snap_id));
 303   }
 304
 305   bool operator!=(const ParentImageSpec& rhs) const {
 306     return !(*this == rhs);
 307   }
 308
 309   void encode(ceph::buffer::list &bl) const;
 310   void decode(ceph::buffer::list::const_iterator &it);
 311   void dump(ceph::Formatter *f) const;
 312
 313   static void generate_test_instances(std::list<ParentImageSpec*> &o);
 314 };
 315
 316 WRITE_CLASS_ENCODER(ParentImageSpec);
 317
 318 std::ostream& operator<<(std::ostream& os, const ParentImageSpec& rhs);
 319
 320 struct ChildImageSpec {
 321   int64_t pool_id = -1;
 322   std::string pool_namespace;
 323   std::string image_id;
 324
 325   ChildImageSpec() {}
 326   ChildImageSpec(int64_t pool_id, const std::string& pool_namespace,
 327                  const std::string& image_id)
 328     : pool_id(pool_id), pool_namespace(pool_namespace), image_id(image_id) {
 329   }
 330
 331   void encode(ceph::buffer::list &bl) const;
 332   void decode(ceph::buffer::list::const_iterator &it);
 333   void dump(ceph::Formatter *f) const;
 334
 335   static void generate_test_instances(std::list<ChildImageSpec*> &o);
 336
 337   inline bool operator==(const ChildImageSpec& rhs) const {
 338     return (pool_id == rhs.pool_id &&
 339             pool_namespace == rhs.pool_namespace &&
 340             image_id == rhs.image_id);
 341   }
 342   inline bool operator<(const ChildImageSpec& rhs) const {
 343     if (pool_id != rhs.pool_id) {
 344       return pool_id < rhs.pool_id;
 345     }
 346     if (pool_namespace != rhs.pool_namespace) {
 347       return pool_namespace < rhs.pool_namespace;
 348     }
 349     return image_id < rhs.image_id;
 350   }
 351 };
 352 WRITE_CLASS_ENCODER(ChildImageSpec);
 353
 354 std::ostream& operator<<(std::ostream& os, const ChildImageSpec& rhs);
 355
 356 typedef std::set<ChildImageSpec> ChildImageSpecs;
 357
 358 struct GroupImageSpec {
 359   GroupImageSpec() {}
 360
 361   GroupImageSpec(const std::string &image_id, int64_t pool_id)
 362     : image_id(image_id), pool_id(pool_id) {}
 363
 364   static int from_key(const std::string &image_key, GroupImageSpec *spec);
 365
 366   std::string image_id;
 367   int64_t pool_id = -1;
 368
 369   void encode(ceph::buffer::list &bl) const;
 370   void decode(ceph::buffer::list::const_iterator &it);
 371   void dump(ceph::Formatter *f) const;
 372
 373   static void generate_test_instances(std::list<GroupImageSpec*> &o);
 374
 375   std::string image_key();
 376
 377 };
 378 WRITE_CLASS_ENCODER(GroupImageSpec);
 379
 380 struct GroupImageStatus {
 381   GroupImageStatus() {}
 382   GroupImageStatus(const std::string &image_id,
 383                    int64_t pool_id,
 384                    GroupImageLinkState state)
 385     : spec(image_id, pool_id), state(state) {}
 386
 387   GroupImageStatus(GroupImageSpec spec,
 388                    GroupImageLinkState state)
 389     : spec(spec), state(state) {}
 390
 391   GroupImageSpec spec;
 392   GroupImageLinkState state = GROUP_IMAGE_LINK_STATE_INCOMPLETE;
 393
 394   void encode(ceph::buffer::list &bl) const;
 395   void decode(ceph::buffer::list::const_iterator &it);
 396   void dump(ceph::Formatter *f) const;
 397
 398   static void generate_test_instances(std::list<GroupImageStatus*> &o);
 399
 400   std::string state_to_string() const;
 401 };
 402
 403 WRITE_CLASS_ENCODER(GroupImageStatus);
 404
 405 struct GroupSpec {
 406   GroupSpec() {}
 407   GroupSpec(const std::string &group_id, int64_t pool_id)
 408     : group_id(group_id), pool_id(pool_id) {}
 409
 410   std::string group_id;
 411   int64_t pool_id = -1;
 412
 413   void encode(ceph::buffer::list &bl) const;
 414   void decode(ceph::buffer::list::const_iterator &it);
 415   void dump(ceph::Formatter *f) const;
 416   bool is_valid() const;
 417
 418   static void generate_test_instances(std::list<GroupSpec *> &o);
 419 };
 420
 421 WRITE_CLASS_ENCODER(GroupSpec);
 422
 423 enum SnapshotNamespaceType {
 424   SNAPSHOT_NAMESPACE_TYPE_USER   = 0,
 425   SNAPSHOT_NAMESPACE_TYPE_GROUP  = 1,
 426   SNAPSHOT_NAMESPACE_TYPE_TRASH  = 2,
 427   SNAPSHOT_NAMESPACE_TYPE_MIRROR = 3,
 428 };
 429
 430 struct UserSnapshotNamespace {
 431   static const SnapshotNamespaceType SNAPSHOT_NAMESPACE_TYPE =
 432     SNAPSHOT_NAMESPACE_TYPE_USER;
 433
 434   UserSnapshotNamespace() {}
 435
 436   void encode(ceph::buffer::list& bl) const {}
 437   void decode(ceph::buffer::list::const_iterator& it) {}
 438
 439   void dump(ceph::Formatter *f) const {}
 440
 441   inline bool operator==(const UserSnapshotNamespace& usn) const {
 442     return true;
 443   }
 444
 445   inline bool operator<(const UserSnapshotNamespace& usn) const {
 446     return false;
 447   }
 448 };
 449
 450 struct GroupSnapshotNamespace {
 451   static const SnapshotNamespaceType SNAPSHOT_NAMESPACE_TYPE =
 452     SNAPSHOT_NAMESPACE_TYPE_GROUP;
 453
 454   GroupSnapshotNamespace() {}
 455
 456   GroupSnapshotNamespace(int64_t _group_pool,
 457                          const std::string &_group_id,
 458                          const std::string &_group_snapshot_id)
 459     : group_id(_group_id), group_pool(_group_pool),
 460       group_snapshot_id(_group_snapshot_id) {}
 461
 462   std::string group_id;
 463   int64_t group_pool = 0;
 464   std::string group_snapshot_id;
 465
 466   void encode(ceph::buffer::list& bl) const;
 467   void decode(ceph::buffer::list::const_iterator& it);
 468
 469   void dump(ceph::Formatter *f) const;
 470
 471   inline bool operator==(const GroupSnapshotNamespace& gsn) const {
 472     return group_pool == gsn.group_pool &&
 473            group_id == gsn.group_id &&
 474            group_snapshot_id == gsn.group_snapshot_id;
 475   }
 476
 477   inline bool operator<(const GroupSnapshotNamespace& gsn) const {
 478     if (group_pool < gsn.group_pool) {
 479       return true;
 480     } else if (group_id < gsn.group_id) {
 481       return true;
 482     } else {
 483       return (group_snapshot_id < gsn.group_snapshot_id);
 484     }
 485     return false;
 486   }
 487 };
 488
 489 struct TrashSnapshotNamespace {
 490   static const SnapshotNamespaceType SNAPSHOT_NAMESPACE_TYPE =
 491     SNAPSHOT_NAMESPACE_TYPE_TRASH;
 492
 493   std::string original_name;
 494   SnapshotNamespaceType original_snapshot_namespace_type =
 495     SNAPSHOT_NAMESPACE_TYPE_USER;
 496
 497   TrashSnapshotNamespace() {}
 498   TrashSnapshotNamespace(SnapshotNamespaceType original_snapshot_namespace_type,
 499                          const std::string& original_name)
 500     : original_name(original_name),
 501       original_snapshot_namespace_type(original_snapshot_namespace_type) {}
 502
 503   void encode(ceph::buffer::list& bl) const;
 504   void decode(ceph::buffer::list::const_iterator& it);
 505   void dump(ceph::Formatter *f) const;
 506
 507   inline bool operator==(const TrashSnapshotNamespace& usn) const {
 508     return true;
 509   }
 510   inline bool operator<(const TrashSnapshotNamespace& usn) const {
 511     return false;
 512   }
 513 };
 514
 515 enum MirrorSnapshotState {
 516   MIRROR_SNAPSHOT_STATE_PRIMARY             = 0,
 517   MIRROR_SNAPSHOT_STATE_PRIMARY_DEMOTED     = 1,
 518   MIRROR_SNAPSHOT_STATE_NON_PRIMARY         = 2,
 519   MIRROR_SNAPSHOT_STATE_NON_PRIMARY_DEMOTED = 3,
 520 };
 521
 522 inline void encode(const MirrorSnapshotState &state, ceph::buffer::list& bl,
 523                    uint64_t features=0) {
 524   using ceph::encode;
 525   encode(static_cast<uint8_t>(state), bl);
 526 }
 527
 528 inline void decode(MirrorSnapshotState &state, ceph::buffer::list::const_iterator& it) {
 529   using ceph::decode;
 530   uint8_t int_state;
 531   decode(int_state, it);
 532   state = static_cast<MirrorSnapshotState>(int_state);
 533 }
 534
 535 std::ostream& operator<<(std::ostream& os, MirrorSnapshotState type);
 536
 537 typedef std::map<uint64_t, uint64_t> SnapSeqs;
 538
 539 struct MirrorSnapshotNamespace {
 540   static const SnapshotNamespaceType SNAPSHOT_NAMESPACE_TYPE =
 541     SNAPSHOT_NAMESPACE_TYPE_MIRROR;
 542
 543   MirrorSnapshotState state = MIRROR_SNAPSHOT_STATE_NON_PRIMARY;
 544   bool complete = false;
 545   std::set<std::string> mirror_peer_uuids;
 546
 547   std::string primary_mirror_uuid;
 548   union {
 549     snapid_t primary_snap_id = CEPH_NOSNAP;
 550     snapid_t clean_since_snap_id;
 551   };
 552   uint64_t last_copied_object_number = 0;
 553   SnapSeqs snap_seqs;
 554
 555   MirrorSnapshotNamespace() {
 556   }
 557   MirrorSnapshotNamespace(MirrorSnapshotState state,
 558                           const std::set<std::string> &mirror_peer_uuids,
 559                           const std::string& primary_mirror_uuid,
 560                           snapid_t primary_snap_id)
 561     : state(state), mirror_peer_uuids(mirror_peer_uuids),
 562       primary_mirror_uuid(primary_mirror_uuid),
 563       primary_snap_id(primary_snap_id) {
 564   }
 565   MirrorSnapshotNamespace(MirrorSnapshotState state,
 566                           const std::set<std::string> &mirror_peer_uuids,
 567                           const std::string& primary_mirror_uuid,
 568                           snapid_t primary_snap_id,
 569                           bool complete,
 570                           uint64_t last_copied_object_number,
 571                           const SnapSeqs& snap_seqs)
 572     : state(state), complete(complete), mirror_peer_uuids(mirror_peer_uuids),
 573       primary_mirror_uuid(primary_mirror_uuid),
 574       primary_snap_id(primary_snap_id),
 575       last_copied_object_number(last_copied_object_number),
 576       snap_seqs(snap_seqs) {
 577   }
 578
 579   inline bool is_primary() const {
 580     return (state == MIRROR_SNAPSHOT_STATE_PRIMARY ||
 581             state == MIRROR_SNAPSHOT_STATE_PRIMARY_DEMOTED);
 582   }
 583
 584   inline bool is_non_primary() const {
 585     return (state == MIRROR_SNAPSHOT_STATE_NON_PRIMARY ||
 586             state == MIRROR_SNAPSHOT_STATE_NON_PRIMARY_DEMOTED);
 587   }
 588
 589   inline bool is_demoted() const {
 590     return (state == MIRROR_SNAPSHOT_STATE_PRIMARY_DEMOTED ||
 591             state == MIRROR_SNAPSHOT_STATE_NON_PRIMARY_DEMOTED);
 592   }
 593
 594   inline bool is_orphan() const {
 595     return (is_non_primary() &&
 596             primary_mirror_uuid.empty() &&
 597             primary_snap_id == CEPH_NOSNAP);
 598   }
 599
 600   void encode(ceph::buffer::list& bl) const;
 601   void decode(ceph::buffer::list::const_iterator& it);
 602
 603   void dump(ceph::Formatter *f) const;
 604
 605   inline bool operator==(const MirrorSnapshotNamespace& rhs) const {
 606     return state == rhs.state &&
 607            complete == rhs.complete &&
 608            mirror_peer_uuids == rhs.mirror_peer_uuids &&
 609            primary_mirror_uuid == rhs.primary_mirror_uuid &&
 610            primary_snap_id == rhs.primary_snap_id &&
 611            last_copied_object_number == rhs.last_copied_object_number &&
 612            snap_seqs == rhs.snap_seqs;
 613   }
 614
 615   inline bool operator<(const MirrorSnapshotNamespace& rhs) const {
 616     if (state != rhs.state) {
 617       return state < rhs.state;
 618     } else if (complete != rhs.complete) {
 619       return complete < rhs.complete;
 620     } else if (mirror_peer_uuids != rhs.mirror_peer_uuids) {
 621       return mirror_peer_uuids < rhs.mirror_peer_uuids;
 622     } else if (primary_mirror_uuid != rhs.primary_mirror_uuid) {
 623       return primary_mirror_uuid < rhs.primary_mirror_uuid;
 624     } else if (primary_snap_id != rhs.primary_snap_id) {
 625       return primary_snap_id < rhs.primary_snap_id;
 626     } else if (last_copied_object_number != rhs.last_copied_object_number) {
 627       return last_copied_object_number < rhs.last_copied_object_number;
 628     } else {
 629       return snap_seqs < rhs.snap_seqs;
 630     }
 631   }
 632 };
 633
 634 struct UnknownSnapshotNamespace {
 635   static const SnapshotNamespaceType SNAPSHOT_NAMESPACE_TYPE =
 636     static_cast<SnapshotNamespaceType>(-1);
 637
 638   UnknownSnapshotNamespace() {}
 639
 640   void encode(ceph::buffer::list& bl) const {}
 641   void decode(ceph::buffer::list::const_iterator& it) {}
 642   void dump(ceph::Formatter *f) const {}
 643
 644   inline bool operator==(const UnknownSnapshotNamespace& gsn) const {
 645     return true;
 646   }
 647
 648   inline bool operator<(const UnknownSnapshotNamespace& gsn) const {
 649     return false;
 650   }
 651 };
 652
 653 std::ostream& operator<<(std::ostream& os, const SnapshotNamespaceType& type);
 654 std::ostream& operator<<(std::ostream& os, const UserSnapshotNamespace& ns);
 655 std::ostream& operator<<(std::ostream& os, const GroupSnapshotNamespace& ns);
 656 std::ostream& operator<<(std::ostream& os, const TrashSnapshotNamespace& ns);
 657 std::ostream& operator<<(std::ostream& os, const MirrorSnapshotNamespace& ns);
 658 std::ostream& operator<<(std::ostream& os, const UnknownSnapshotNamespace& ns);
 659
 660 typedef boost::variant<UserSnapshotNamespace,
 661                        GroupSnapshotNamespace,
 662                        TrashSnapshotNamespace,
 663                        MirrorSnapshotNamespace,
 664                        UnknownSnapshotNamespace> SnapshotNamespaceVariant;
 665
 666 struct SnapshotNamespace : public SnapshotNamespaceVariant {
 667   SnapshotNamespace() {
 668   }
 669
 670   template <typename T>
 671   SnapshotNamespace(T&& t) : SnapshotNamespaceVariant(std::forward<T>(t)) {
 672   }
 673
 674   void encode(ceph::buffer::list& bl) const;
 675   void decode(ceph::buffer::list::const_iterator& it);
 676   void dump(ceph::Formatter *f) const;
 677
 678   static void generate_test_instances(std::list<SnapshotNamespace*> &o);
 679
 680   inline bool operator==(const SnapshotNamespaceVariant& sn) const {
 681     return static_cast<const SnapshotNamespaceVariant&>(*this) == sn;
 682   }
 683   inline bool operator<(const SnapshotNamespaceVariant& sn) const {
 684     return static_cast<const SnapshotNamespaceVariant&>(*this) < sn;
 685   }
 686   inline bool operator!=(const SnapshotNamespaceVariant& sn) const {
 687     return !(*this == sn);
 688   }
 689 };
 690 WRITE_CLASS_ENCODER(SnapshotNamespace);
 691
 692 SnapshotNamespaceType get_snap_namespace_type(
 693     const SnapshotNamespace& snapshot_namespace);
 694
 695 struct SnapshotInfo {
 696   snapid_t id = CEPH_NOSNAP;
 697   cls::rbd::SnapshotNamespace snapshot_namespace = {UserSnapshotNamespace{}};
 698   std::string name;
 699   uint64_t image_size = 0;
 700   utime_t timestamp;
 701   uint32_t child_count = 0;
 702
 703   SnapshotInfo() {
 704   }
 705   SnapshotInfo(snapid_t id,
 706                const cls::rbd::SnapshotNamespace& snapshot_namespace,
 707                const std::string& name, uint64_t image_size,
 708                const utime_t& timestamp, uint32_t child_count)
 709     : id(id), snapshot_namespace(snapshot_namespace),
 710       name(name), image_size(image_size), timestamp(timestamp),
 711       child_count(child_count) {
 712   }
 713
 714   void encode(ceph::buffer::list& bl) const;
 715   void decode(ceph::buffer::list::const_iterator& it);
 716   void dump(ceph::Formatter *f) const;
 717
 718   static void generate_test_instances(std::list<SnapshotInfo*> &o);
 719 };
 720 WRITE_CLASS_ENCODER(SnapshotInfo);
 721
 722 enum GroupSnapshotState {
 723   GROUP_SNAPSHOT_STATE_INCOMPLETE = 0,
 724   GROUP_SNAPSHOT_STATE_COMPLETE = 1,
 725 };
 726
 727 inline void encode(const GroupSnapshotState &state, ceph::buffer::list& bl, uint64_t features=0)
 728 {
 729   using ceph::encode;
 730   encode(static_cast<uint8_t>(state), bl);
 731 }
 732
 733 inline void decode(GroupSnapshotState &state, ceph::buffer::list::const_iterator& it)
 734 {
 735   using ceph::decode;
 736   uint8_t int_state;
 737   decode(int_state, it);
 738   state = static_cast<GroupSnapshotState>(int_state);
 739 }
 740
 741 struct ImageSnapshotSpec {
 742   int64_t pool;
 743   std::string image_id;
 744   snapid_t snap_id;
 745
 746   ImageSnapshotSpec() {}
 747   ImageSnapshotSpec(int64_t _pool,
 748                     std::string _image_id,
 749                     snapid_t _snap_id) : pool(_pool),
 750                                          image_id(_image_id),
 751                                          snap_id(_snap_id) {}
 752
 753   void encode(ceph::buffer::list& bl) const;
 754   void decode(ceph::buffer::list::const_iterator& it);
 755
 756   void dump(ceph::Formatter *f) const;
 757
 758   static void generate_test_instances(std::list<ImageSnapshotSpec *> &o);
 759 };
 760 WRITE_CLASS_ENCODER(ImageSnapshotSpec);
 761
 762 struct GroupSnapshot {
 763   std::string id;
 764   std::string name;
 765   GroupSnapshotState state = GROUP_SNAPSHOT_STATE_INCOMPLETE;
 766
 767   GroupSnapshot() {}
 768   GroupSnapshot(std::string _id,
 769                 std::string _name,
 770                 GroupSnapshotState _state) : id(_id),
 771                                              name(_name),
 772                                              state(_state) {}
 773
 774   std::vector<ImageSnapshotSpec> snaps;
 775
 776   void encode(ceph::buffer::list& bl) const;
 777   void decode(ceph::buffer::list::const_iterator& it);
 778   void dump(ceph::Formatter *f) const;
 779
 780   static void generate_test_instances(std::list<GroupSnapshot *> &o);
 781 };
 782 WRITE_CLASS_ENCODER(GroupSnapshot);
 783 enum TrashImageSource {
 784   TRASH_IMAGE_SOURCE_USER = 0,
 785   TRASH_IMAGE_SOURCE_MIRRORING = 1,
 786   TRASH_IMAGE_SOURCE_MIGRATION = 2,
 787   TRASH_IMAGE_SOURCE_REMOVING = 3,
 788   TRASH_IMAGE_SOURCE_USER_PARENT= 4,
 789 };
 790
 791 inline std::ostream& operator<<(std::ostream& os,
 792                                 const TrashImageSource& source) {
 793   switch (source) {
 794   case TRASH_IMAGE_SOURCE_USER:
 795     os << "user";
 796     break;
 797   case TRASH_IMAGE_SOURCE_MIRRORING:
 798     os << "mirroring";
 799     break;
 800   case TRASH_IMAGE_SOURCE_MIGRATION:
 801     os << "migration";
 802     break;
 803   case TRASH_IMAGE_SOURCE_REMOVING:
 804     os << "removing";
 805     break;
 806   default:
 807     os << "unknown (" << static_cast<uint32_t>(source) << ")";
 808     break;
 809   }
 810   return os;
 811 }
 812
 813 inline void encode(const TrashImageSource &source, ceph::buffer::list& bl,
 814                    uint64_t features=0)
 815 {
 816   using ceph::encode;
 817   encode(static_cast<uint8_t>(source), bl);
 818 }
 819
 820 inline void decode(TrashImageSource &source, ceph::buffer::list::const_iterator& it)
 821 {
 822   uint8_t int_source;
 823   using ceph::decode;
 824   decode(int_source, it);
 825   source = static_cast<TrashImageSource>(int_source);
 826 }
 827
 828 enum TrashImageState {
 829   TRASH_IMAGE_STATE_NORMAL    = 0,
 830   TRASH_IMAGE_STATE_MOVING    = 1,
 831   TRASH_IMAGE_STATE_REMOVING  = 2,
 832   TRASH_IMAGE_STATE_RESTORING = 3
 833 };
 834
 835 inline void encode(const TrashImageState &state, ceph::buffer::list &bl)
 836 {
 837   using ceph::encode;
 838   encode(static_cast<uint8_t>(state), bl);
 839 }
 840
 841 inline void decode(TrashImageState &state, ceph::buffer::list::const_iterator &it)
 842 {
 843   uint8_t int_state;
 844   using ceph::decode;
 845   decode(int_state, it);
 846   state = static_cast<TrashImageState>(int_state);
 847 }
 848
 849 struct TrashImageSpec {
 850   TrashImageSource source = TRASH_IMAGE_SOURCE_USER;
 851   std::string name;
 852   utime_t deletion_time; // time of deletion
 853   utime_t deferment_end_time;
 854   TrashImageState state = TRASH_IMAGE_STATE_NORMAL;
 855
 856   TrashImageSpec() {}
 857   TrashImageSpec(TrashImageSource source, const std::string &name,
 858                  const utime_t& deletion_time,
 859                  const utime_t& deferment_end_time)
 860     : source(source), name(name), deletion_time(deletion_time),
 861       deferment_end_time(deferment_end_time) {
 862   }
 863
 864   void encode(ceph::buffer::list &bl) const;
 865   void decode(ceph::buffer::list::const_iterator& it);
 866   void dump(ceph::Formatter *f) const;
 867
 868   inline bool operator==(const TrashImageSpec& rhs) const {
 869     return (source == rhs.source &&
 870             name == rhs.name &&
 871             deletion_time == rhs.deletion_time &&
 872             deferment_end_time == rhs.deferment_end_time);
 873   }
 874 };
 875 WRITE_CLASS_ENCODER(TrashImageSpec);
 876
 877 struct MirrorImageMap {
 878   MirrorImageMap() {
 879   }
 880
 881   MirrorImageMap(const std::string &instance_id, utime_t mapped_time,
 882                  const ceph::buffer::list &data)
 883     : instance_id(instance_id),
 884       mapped_time(mapped_time),
 885       data(data) {
 886   }
 887
 888   std::string instance_id;
 889   utime_t mapped_time;
 890   ceph::buffer::list data;
 891
 892   void encode(ceph::buffer::list &bl) const;
 893   void decode(ceph::buffer::list::const_iterator &it);
 894   void dump(ceph::Formatter *f) const;
 895
 896   static void generate_test_instances(std::list<MirrorImageMap*> &o);
 897
 898   bool operator==(const MirrorImageMap &rhs) const;
 899   bool operator<(const MirrorImageMap &rhs) const;
 900 };
 901
 902 std::ostream& operator<<(std::ostream& os, const MirrorImageMap &image_map);
 903
 904 WRITE_CLASS_ENCODER(MirrorImageMap);
 905
 906 enum MigrationHeaderType {
 907   MIGRATION_HEADER_TYPE_SRC = 1,
 908   MIGRATION_HEADER_TYPE_DST = 2,
 909 };
 910
 911 inline void encode(const MigrationHeaderType &type, ceph::buffer::list& bl) {
 912   using ceph::encode;
 913   encode(static_cast<uint8_t>(type), bl);
 914 }
 915
 916 inline void decode(MigrationHeaderType &type, ceph::buffer::list::const_iterator& it) {
 917   uint8_t int_type;
 918   using ceph::decode;
 919   decode(int_type, it);
 920   type = static_cast<MigrationHeaderType>(int_type);
 921 }
 922
 923 enum MigrationState {
 924   MIGRATION_STATE_ERROR = 0,
 925   MIGRATION_STATE_PREPARING = 1,
 926   MIGRATION_STATE_PREPARED = 2,
 927   MIGRATION_STATE_EXECUTING = 3,
 928   MIGRATION_STATE_EXECUTED = 4,
 929   MIGRATION_STATE_ABORTING = 5,
 930 };
 931
 932 inline void encode(const MigrationState &state, ceph::buffer::list& bl) {
 933   using ceph::encode;
 934   encode(static_cast<uint8_t>(state), bl);
 935 }
 936
 937 inline void decode(MigrationState &state, ceph::buffer::list::const_iterator& it) {
 938   uint8_t int_state;
 939   using ceph::decode;
 940   decode(int_state, it);
 941   state = static_cast<MigrationState>(int_state);
 942 }
 943
 944 std::ostream& operator<<(std::ostream& os,
 945                          const MigrationState& migration_state);
 946
 947 struct MigrationSpec {
 948   MigrationHeaderType header_type = MIGRATION_HEADER_TYPE_SRC;
 949   int64_t pool_id = -1;
 950   std::string pool_namespace;
 951   std::string image_name;
 952   std::string image_id;
 953   std::string source_spec;
 954   std::map<uint64_t, uint64_t> snap_seqs;
 955   uint64_t overlap = 0;
 956   bool flatten = false;
 957   bool mirroring = false;
 958   MirrorImageMode mirror_image_mode = MIRROR_IMAGE_MODE_JOURNAL;
 959   MigrationState state = MIGRATION_STATE_ERROR;
 960   std::string state_description;
 961
 962   MigrationSpec() {
 963   }
 964   MigrationSpec(MigrationHeaderType header_type, int64_t pool_id,
 965                 const std::string& pool_namespace,
 966                 const std::string& image_name, const std::string &image_id,
 967                 const std::string& source_spec,
 968                 const std::map<uint64_t, uint64_t> &snap_seqs, uint64_t overlap,
 969                 bool mirroring, MirrorImageMode mirror_image_mode, bool flatten,
 970                 MigrationState state, const std::string &state_description)
 971     : header_type(header_type), pool_id(pool_id),
 972       pool_namespace(pool_namespace), image_name(image_name),
 973       image_id(image_id), source_spec(source_spec), snap_seqs(snap_seqs),
 974       overlap(overlap), flatten(flatten), mirroring(mirroring),
 975       mirror_image_mode(mirror_image_mode), state(state),
 976       state_description(state_description) {
 977   }
 978
 979   void encode(ceph::buffer::list &bl) const;
 980   void decode(ceph::buffer::list::const_iterator& it);
 981   void dump(ceph::Formatter *f) const;
 982
 983   static void generate_test_instances(std::list<MigrationSpec*> &o);
 984
 985   inline bool operator==(const MigrationSpec& ms) const {
 986     return header_type == ms.header_type && pool_id == ms.pool_id &&
 987       pool_namespace == ms.pool_namespace && image_name == ms.image_name &&
 988       image_id == ms.image_id && source_spec == ms.source_spec &&
 989       snap_seqs == ms.snap_seqs && overlap == ms.overlap &&
 990       flatten == ms.flatten && mirroring == ms.mirroring &&
 991       mirror_image_mode == ms.mirror_image_mode && state == ms.state &&
 992       state_description == ms.state_description;
 993   }
 994 };
 995
 996 std::ostream& operator<<(std::ostream& os, const MigrationSpec& migration_spec);
 997
 998 WRITE_CLASS_ENCODER(MigrationSpec);
 999
1000 enum AssertSnapcSeqState {
1001   ASSERT_SNAPC_SEQ_GT_SNAPSET_SEQ = 0,
1002   ASSERT_SNAPC_SEQ_LE_SNAPSET_SEQ = 1,
1003 };
1004
1005 inline void encode(const AssertSnapcSeqState &state, ceph::buffer::list& bl) {
1006   using ceph::encode;
1007   encode(static_cast<uint8_t>(state), bl);
1008 }
1009
1010 inline void decode(AssertSnapcSeqState &state, ceph::buffer::list::const_iterator& it) {
1011   uint8_t int_state;
1012   using ceph::decode;
1013   decode(int_state, it);
1014   state = static_cast<AssertSnapcSeqState>(int_state);
1015 }
1016
1017 std::ostream& operator<<(std::ostream& os, const AssertSnapcSeqState& state);
1018
1019 void sanitize_entity_inst(entity_inst_t* entity_inst);
1020
1021 } // namespace rbd
1022 } // namespace cls
1023
1024 #endif // CEPH_CLS_RBD_TYPES_H