librbd: rename MirrorPrimarySnapshotNamespace to MirrorSnapshotNamespace

This is the first pass at merging primary and non-primary mirror snapshots
together into a unified namespace.

Signed-off-by: Jason Dillaman <dillaman@redhat.com>

diff --git a/src/cls/rbd/cls_rbd.cc b/src/cls/rbd/cls_rbd.cc
index 4305f3f176cb7604e126ca6619a6101275616266..f311137da6add0e28bd196b89f03752e3dd42d93 100644 (file)
--- a/src/cls/rbd/cls_rbd.cc
+++ b/src/cls/rbd/cls_rbd.cc
@@ -5683,24 +5683,24 @@ int image_snapshot_unlink_peer(cls_method_context_t hctx,
     return r;
   }
 
-  auto primary = boost::get<cls::rbd::MirrorPrimarySnapshotNamespace>(
+  auto mirror_ns = boost::get<cls::rbd::MirrorSnapshotNamespace>(
     &snap.snapshot_namespace);
-  if (primary == nullptr) {
+  if (mirror_ns == nullptr) {
     CLS_LOG(5, "mirror_image_snapshot_unlink_peer " \
             "not mirroring snapshot snap_id=%" PRIu64, snap_id);
     return -EINVAL;
   }
 
-  if (primary->mirror_peer_uuids.count(mirror_peer_uuid) == 0) {
+  if (mirror_ns->mirror_peer_uuids.count(mirror_peer_uuid) == 0) {
     return -ENOENT;
   }
 
-  if (primary->mirror_peer_uuids.size() == 1) {
+  if (mirror_ns->mirror_peer_uuids.size() == 1) {
     // return a special error when trying to unlink the last peer
     return -ERESTART;
   }
 
-  primary->mirror_peer_uuids.erase(mirror_peer_uuid);
+  mirror_ns->mirror_peer_uuids.erase(mirror_peer_uuid);
 
   r = image::snapshot::write(hctx, snap_key, std::move(snap));
   if (r < 0) {

diff --git a/src/cls/rbd/cls_rbd_types.cc b/src/cls/rbd/cls_rbd_types.cc
index e72821ccff0a70447662e8923958931d6dab23ab..160d89391b9f32707b921ee62fc53d5b45135efe 100644 (file)
--- a/src/cls/rbd/cls_rbd_types.cc
+++ b/src/cls/rbd/cls_rbd_types.cc
@@ -718,25 +718,40 @@ void TrashSnapshotNamespace::dump(Formatter *f) const {
     << original_snapshot_namespace_type;
 }
 
-void MirrorPrimarySnapshotNamespace::encode(bufferlist& bl) const {
+void MirrorSnapshotNamespace::encode(bufferlist& bl) const {
   using ceph::encode;
-  encode(demoted, bl);
+  encode(state, bl);
+  encode(complete, bl);
   encode(mirror_peer_uuids, bl);
+  encode(primary_mirror_uuid, bl);
+  encode(primary_snap_id, bl);
+  encode(last_copied_object_number, bl);
+  encode(snap_seqs, bl);
 }
 
-void MirrorPrimarySnapshotNamespace::decode(bufferlist::const_iterator& it) {
+void MirrorSnapshotNamespace::decode(bufferlist::const_iterator& it) {
   using ceph::decode;
-  decode(demoted, it);
+  decode(state, it);
+  decode(complete, it);
   decode(mirror_peer_uuids, it);
+  decode(primary_mirror_uuid, it);
+  decode(primary_snap_id, it);
+  decode(last_copied_object_number, it);
+  decode(snap_seqs, it);
 }
 
-void MirrorPrimarySnapshotNamespace::dump(Formatter *f) const {
-  f->dump_bool("demoted", demoted);
+void MirrorSnapshotNamespace::dump(Formatter *f) const {
+  f->dump_stream("state") << state;
+  f->dump_bool("complete", complete);
   f->open_array_section("mirror_peer_uuids");
   for (auto &peer : mirror_peer_uuids) {
     f->dump_string("mirror_peer_uuid", peer);
   }
   f->close_section();
+  f->dump_string("primary_mirror_uuid", primary_mirror_uuid);
+  f->dump_unsigned("primary_snap_id", primary_snap_id);
+  f->dump_unsigned("last_copied_object_number", last_copied_object_number);
+  f->dump_stream("snap_seqs") << snap_seqs;
 }
 
 void MirrorNonPrimarySnapshotNamespace::encode(bufferlist& bl) const {
@@ -869,7 +884,12 @@ void SnapshotInfo::generate_test_instances(std::list<SnapshotInfo*> &o) {
                                  SNAPSHOT_NAMESPACE_TYPE_USER, "snap1"},
                                "12345", 123, {123456, 0}, 429));
   o.push_back(new SnapshotInfo(1ULL,
-                               MirrorPrimarySnapshotNamespace{true, {"1", "2"}},
+                               MirrorSnapshotNamespace{MIRROR_SNAPSHOT_STATE_PRIMARY,
+                                                       {"1", "2"}, "", CEPH_NOSNAP},
+                               "snap1", 123, {123456, 0}, 12));
+  o.push_back(new SnapshotInfo(1ULL,
+                               MirrorSnapshotNamespace{MIRROR_SNAPSHOT_STATE_NON_PRIMARY,
+                                                       {"1", "2"}, "uuid", 123},
                                "snap1", 123, {123456, 0}, 12));
   o.push_back(new SnapshotInfo(1ULL,
                                MirrorNonPrimarySnapshotNamespace{"uuid", 111},
@@ -897,8 +917,8 @@ void SnapshotNamespace::decode(bufferlist::const_iterator &p)
     case cls::rbd::SNAPSHOT_NAMESPACE_TYPE_TRASH:
       *this = TrashSnapshotNamespace();
       break;
-    case cls::rbd::SNAPSHOT_NAMESPACE_TYPE_MIRROR_PRIMARY:
-      *this = MirrorPrimarySnapshotNamespace();
+    case cls::rbd::SNAPSHOT_NAMESPACE_TYPE_MIRROR:
+      *this = MirrorSnapshotNamespace();
       break;
     case cls::rbd::SNAPSHOT_NAMESPACE_TYPE_MIRROR_NON_PRIMARY:
       *this = MirrorNonPrimarySnapshotNamespace();
@@ -923,8 +943,18 @@ void SnapshotNamespace::generate_test_instances(std::list<SnapshotNamespace*> &o
   o.push_back(new SnapshotNamespace(GroupSnapshotNamespace(5, "1018643c9869",
                                                            "33352be8933c")));
   o.push_back(new SnapshotNamespace(TrashSnapshotNamespace()));
-  o.push_back(new SnapshotNamespace(MirrorPrimarySnapshotNamespace(true,
-                                                                   {"uuid"})));
+  o.push_back(new SnapshotNamespace(MirrorSnapshotNamespace(MIRROR_SNAPSHOT_STATE_PRIMARY,
+                                                            {"peer uuid"},
+                                                            "", CEPH_NOSNAP)));
+  o.push_back(new SnapshotNamespace(MirrorSnapshotNamespace(MIRROR_SNAPSHOT_STATE_PRIMARY_DEMOTED,
+                                                            {"peer uuid"},
+                                                            "", CEPH_NOSNAP)));
+  o.push_back(new SnapshotNamespace(MirrorSnapshotNamespace(MIRROR_SNAPSHOT_STATE_NON_PRIMARY,
+                                                            {"peer uuid"},
+                                                            "uuid", 123)));
+  o.push_back(new SnapshotNamespace(MirrorSnapshotNamespace(MIRROR_SNAPSHOT_STATE_NON_PRIMARY_DEMOTED,
+                                                            {"peer uuid"},
+                                                            "uuid", 123)));
   o.push_back(new SnapshotNamespace(MirrorNonPrimarySnapshotNamespace("", 0)));
 }
 
@@ -939,8 +969,8 @@ std::ostream& operator<<(std::ostream& os, const SnapshotNamespaceType& type) {
   case SNAPSHOT_NAMESPACE_TYPE_TRASH:
     os << "trash";
     break;
-  case SNAPSHOT_NAMESPACE_TYPE_MIRROR_PRIMARY:
-    os << "mirror_primary";
+  case SNAPSHOT_NAMESPACE_TYPE_MIRROR:
+    os << "mirror";
     break;
   case SNAPSHOT_NAMESPACE_TYPE_MIRROR_NON_PRIMARY:
     os << "mirror_non_primary";
@@ -973,11 +1003,15 @@ std::ostream& operator<<(std::ostream& os, const TrashSnapshotNamespace& ns) {
   return os;
 }
 
-std::ostream& operator<<(std::ostream& os,
-                         const MirrorPrimarySnapshotNamespace& ns) {
-  os << "[" << SNAPSHOT_NAMESPACE_TYPE_MIRROR_PRIMARY << " "
-     << "demoted=" << ns.demoted << ", "
-     << "mirror_peer_uuids=" << ns.mirror_peer_uuids
+std::ostream& operator<<(std::ostream& os, const MirrorSnapshotNamespace& ns) {
+  os << "[" << SNAPSHOT_NAMESPACE_TYPE_MIRROR << " "
+     << "state=" << ns.state << ", "
+     << "complete=" << ns.complete << ", "
+     << "mirror_peer_uuids=" << ns.mirror_peer_uuids << ", "
+     << "primary_mirror_uuid=" << ns.primary_mirror_uuid << ", "
+     << "primary_snap_id=" << ns.primary_snap_id << ", "
+     << "last_copied_object_number=" << ns.last_copied_object_number << ", "
+     << "snap_seqs=" << ns.snap_seqs
      << "]";
   return os;
 }
@@ -999,6 +1033,28 @@ std::ostream& operator<<(std::ostream& os, const UnknownSnapshotNamespace& ns) {
   return os;
 }
 
+std::ostream& operator<<(std::ostream& os, MirrorSnapshotState type) {
+  switch (type) {
+  case MIRROR_SNAPSHOT_STATE_PRIMARY:
+    os << "primary";
+    break;
+  case MIRROR_SNAPSHOT_STATE_PRIMARY_DEMOTED:
+    os << "primary (demoted)";
+    break;
+  case MIRROR_SNAPSHOT_STATE_NON_PRIMARY:
+    os << "non-primary";
+    break;
+  case MIRROR_SNAPSHOT_STATE_NON_PRIMARY_DEMOTED:
+    os << "demoted (demoted)";
+    break;
+  default:
+    os << "unknown";
+    break;
+  }
+  return os;
+
+}
+
 void ImageSnapshotSpec::encode(bufferlist& bl) const {
   using ceph::encode;
   ENCODE_START(1, 1, bl);

diff --git a/src/cls/rbd/cls_rbd_types.h b/src/cls/rbd/cls_rbd_types.h
index d4e5f2be5a42218920dd4770016747bc3bee4d83..d1d21ef067539233932d03328a179419b7840bae 100644 (file)
--- a/src/cls/rbd/cls_rbd_types.h
+++ b/src/cls/rbd/cls_rbd_types.h
@@ -420,7 +420,7 @@ enum SnapshotNamespaceType {
   SNAPSHOT_NAMESPACE_TYPE_USER               = 0,
   SNAPSHOT_NAMESPACE_TYPE_GROUP              = 1,
   SNAPSHOT_NAMESPACE_TYPE_TRASH              = 2,
-  SNAPSHOT_NAMESPACE_TYPE_MIRROR_PRIMARY     = 3,
+  SNAPSHOT_NAMESPACE_TYPE_MIRROR             = 3,
   SNAPSHOT_NAMESPACE_TYPE_MIRROR_NON_PRIMARY = 4,
 };
 
@@ -509,18 +509,67 @@ struct TrashSnapshotNamespace {
   }
 };
 
-struct MirrorPrimarySnapshotNamespace {
+enum MirrorSnapshotState {
+  MIRROR_SNAPSHOT_STATE_PRIMARY             = 0,
+  MIRROR_SNAPSHOT_STATE_PRIMARY_DEMOTED     = 1,
+  MIRROR_SNAPSHOT_STATE_NON_PRIMARY         = 2,
+  MIRROR_SNAPSHOT_STATE_NON_PRIMARY_DEMOTED = 3,
+};
+
+inline void encode(const MirrorSnapshotState &state, bufferlist& bl,
+                   uint64_t features=0) {
+  using ceph::encode;
+  encode(static_cast<uint8_t>(state), bl);
+}
+
+inline void decode(MirrorSnapshotState &state, bufferlist::const_iterator& it) {
+  using ceph::decode;
+  uint8_t int_state;
+  decode(int_state, it);
+  state = static_cast<MirrorSnapshotState>(int_state);
+}
+
+std::ostream& operator<<(std::ostream& os, MirrorSnapshotState type);
+
+typedef std::map<uint64_t, uint64_t> SnapSeqs;
+
+struct MirrorSnapshotNamespace {
   static const SnapshotNamespaceType SNAPSHOT_NAMESPACE_TYPE =
-    SNAPSHOT_NAMESPACE_TYPE_MIRROR_PRIMARY;
+    SNAPSHOT_NAMESPACE_TYPE_MIRROR;
 
-  bool demoted = false;
+  MirrorSnapshotState state = MIRROR_SNAPSHOT_STATE_NON_PRIMARY;
+  bool complete = false;
   std::set<std::string> mirror_peer_uuids;
 
-  MirrorPrimarySnapshotNamespace() {
+  std::string primary_mirror_uuid;
+  snapid_t primary_snap_id = CEPH_NOSNAP;
+  uint64_t last_copied_object_number = 0;
+  SnapSeqs snap_seqs;
+
+  MirrorSnapshotNamespace() {
   }
-  MirrorPrimarySnapshotNamespace(bool demoted,
-                                 const std::set<std::string> &mirror_peer_uuids)
-    : demoted(demoted), mirror_peer_uuids(mirror_peer_uuids) {
+  MirrorSnapshotNamespace(MirrorSnapshotState state,
+                          const std::set<std::string> &mirror_peer_uuids,
+                          const std::string& primary_mirror_uuid,
+                          snapid_t primary_snap_id)
+    : state(state), mirror_peer_uuids(mirror_peer_uuids),
+      primary_mirror_uuid(primary_mirror_uuid),
+      primary_snap_id(primary_snap_id) {
+  }
+
+  inline bool is_primary() const {
+    return (state == MIRROR_SNAPSHOT_STATE_PRIMARY ||
+            state == MIRROR_SNAPSHOT_STATE_PRIMARY_DEMOTED);
+  }
+
+  inline bool is_non_primary() const {
+    return (state == MIRROR_SNAPSHOT_STATE_NON_PRIMARY ||
+            state == MIRROR_SNAPSHOT_STATE_NON_PRIMARY_DEMOTED);
+  }
+
+  inline bool is_demoted() const {
+    return (state == MIRROR_SNAPSHOT_STATE_PRIMARY_DEMOTED ||
+            state == MIRROR_SNAPSHOT_STATE_NON_PRIMARY_DEMOTED);
   }
 
   void encode(bufferlist& bl) const;
@@ -528,21 +577,35 @@ struct MirrorPrimarySnapshotNamespace {
 
   void dump(Formatter *f) const;
 
-  inline bool operator==(const MirrorPrimarySnapshotNamespace& mpsn) const {
-    return demoted == mpsn.demoted &&
-           mirror_peer_uuids == mpsn.mirror_peer_uuids;
+  inline bool operator==(const MirrorSnapshotNamespace& rhs) const {
+    return state == rhs.state &&
+           complete == rhs.complete &&
+           mirror_peer_uuids == rhs.mirror_peer_uuids &&
+           primary_mirror_uuid == rhs.primary_mirror_uuid &&
+           primary_snap_id == rhs.primary_snap_id &&
+           last_copied_object_number == rhs.last_copied_object_number &&
+           snap_seqs == rhs.snap_seqs;
   }
 
-  inline bool operator<(const MirrorPrimarySnapshotNamespace& mpsn) const {
-    if (demoted != mpsn.demoted) {
-      return demoted < mpsn.demoted;
+  inline bool operator<(const MirrorSnapshotNamespace& rhs) const {
+    if (state != rhs.state) {
+      return state < rhs.state;
+    } else if (complete != rhs.complete) {
+      return complete < rhs.complete;
+    } else if (mirror_peer_uuids != rhs.mirror_peer_uuids) {
+      return mirror_peer_uuids < rhs.mirror_peer_uuids;
+    } else if (primary_mirror_uuid != rhs.primary_mirror_uuid) {
+      return primary_mirror_uuid < rhs.primary_mirror_uuid;
+    } else if (primary_snap_id != rhs.primary_snap_id) {
+      return primary_snap_id < rhs.primary_snap_id;
+    } else if (last_copied_object_number != rhs.last_copied_object_number) {
+      return last_copied_object_number < rhs.last_copied_object_number;
+    } else {
+      return snap_seqs < rhs.snap_seqs;
     }
-    return mirror_peer_uuids < mpsn.mirror_peer_uuids;
   }
 };
 
-typedef std::map<uint64_t, uint64_t> SnapSeqs;
-
 struct MirrorNonPrimarySnapshotNamespace {
   static const SnapshotNamespaceType SNAPSHOT_NAMESPACE_TYPE =
     SNAPSHOT_NAMESPACE_TYPE_MIRROR_NON_PRIMARY;
@@ -609,8 +672,7 @@ std::ostream& operator<<(std::ostream& os, const SnapshotNamespaceType& type);
 std::ostream& operator<<(std::ostream& os, const UserSnapshotNamespace& ns);
 std::ostream& operator<<(std::ostream& os, const GroupSnapshotNamespace& ns);
 std::ostream& operator<<(std::ostream& os, const TrashSnapshotNamespace& ns);
-std::ostream& operator<<(std::ostream& os,
-                         const MirrorPrimarySnapshotNamespace& ns);
+std::ostream& operator<<(std::ostream& os, const MirrorSnapshotNamespace& ns);
 std::ostream& operator<<(std::ostream& os,
                          const MirrorNonPrimarySnapshotNamespace& ns);
 std::ostream& operator<<(std::ostream& os, const UnknownSnapshotNamespace& ns);
@@ -618,7 +680,7 @@ std::ostream& operator<<(std::ostream& os, const UnknownSnapshotNamespace& ns);
 typedef boost::variant<UserSnapshotNamespace,
                        GroupSnapshotNamespace,
                        TrashSnapshotNamespace,
-                       MirrorPrimarySnapshotNamespace,
+                       MirrorSnapshotNamespace,
                        MirrorNonPrimarySnapshotNamespace,
                        UnknownSnapshotNamespace> SnapshotNamespaceVariant;
 

diff --git a/src/librbd/api/Mirror.cc b/src/librbd/api/Mirror.cc
index 3b1d47072ae3d91921c47f48393fdbb1b51ecf2b..88ef8d41fbbad26ccdfc2e86d354fec87f3baa66 100644 (file)
--- a/src/librbd/api/Mirror.cc
+++ b/src/librbd/api/Mirror.cc
@@ -1470,7 +1470,7 @@ int Mirror<I>::peer_site_remove(librados::IoCtx& io_ctx,
       {
         std::shared_lock image_locker{img_ctx->image_lock};
         for (auto &it : img_ctx->snap_info) {
-          auto info = boost::get<cls::rbd::MirrorPrimarySnapshotNamespace>(
+          auto info = boost::get<cls::rbd::MirrorSnapshotNamespace>(
             &it.second.snap_namespace);
           if (info && info->mirror_peer_uuids.count(uuid)) {
             snap_ids.push_back(it.first);

diff --git a/src/librbd/api/Snapshot.cc b/src/librbd/api/Snapshot.cc
index d13ac77581619354a40a89bcca9f3b2a6e85a5d6..bc815341b3709136b0ef4264aad5551efd87fa92 100644 (file)
--- a/src/librbd/api/Snapshot.cc
+++ b/src/librbd/api/Snapshot.cc
@@ -10,7 +10,6 @@
 #include "librbd/Operations.h"
 #include "librbd/Utils.h"
 #include "librbd/api/Image.h"
-#include "librbd/api/Mirror.h"
 #include <boost/variant.hpp>
 #include "include/Context.h"
 #include "common/Cond.h"
@@ -103,11 +102,9 @@ public:
 class GetMirrorVisitor : public boost::static_visitor<int> {
 public:
   snap_mirror_namespace_t *mirror_snap;
-  std::string mirror_uuid;
 
-  explicit GetMirrorVisitor(snap_mirror_namespace_t *mirror_snap,
-                            const std::string& mirror_uuid)
-    : mirror_snap(mirror_snap), mirror_uuid(mirror_uuid) {
+  explicit GetMirrorVisitor(snap_mirror_namespace_t *mirror_snap)
+    : mirror_snap(mirror_snap) {
   }
 
   template <typename T>
@@ -116,14 +113,14 @@ public:
   }
 
   inline int operator()(
-      const cls::rbd::MirrorPrimarySnapshotNamespace& snap_namespace) {
-    if (snap_namespace.demoted) {
-      mirror_snap->state = RBD_SNAP_MIRROR_STATE_PRIMARY_DEMOTED;
-    } else {
-      mirror_snap->state = RBD_SNAP_MIRROR_STATE_PRIMARY;
-    }
+      const cls::rbd::MirrorSnapshotNamespace& snap_namespace) {
+    mirror_snap->state = static_cast<snap_mirror_state_t>(snap_namespace.state);
+    mirror_snap->complete = snap_namespace.complete;
     mirror_snap->mirror_peer_uuids = snap_namespace.mirror_peer_uuids;
-    mirror_snap->complete = true;
+    mirror_snap->primary_mirror_uuid = snap_namespace.primary_mirror_uuid;
+    mirror_snap->primary_snap_id = snap_namespace.primary_snap_id;
+    mirror_snap->last_copied_object_number =
+      snap_namespace.last_copied_object_number;
     return 0;
   }
 
@@ -201,14 +198,7 @@ int Snapshot<I>::get_mirror_namespace(
     return -ENOENT;
   }
 
-  // TODO temporary
-  std::string mirror_uuid;
-  r = Mirror<I>::uuid_get(ictx->md_ctx, &mirror_uuid);
-  if (r < 0) {
-    return r;
-  }
-
-  auto gmv = GetMirrorVisitor(mirror_snap, mirror_uuid);
+  auto gmv = GetMirrorVisitor(mirror_snap);
   r = boost::apply_visitor(gmv, snap_info->snap_namespace);
   if (r < 0) {
     return r;

diff --git a/src/librbd/deep_copy/SnapshotCopyRequest.cc b/src/librbd/deep_copy/SnapshotCopyRequest.cc
index bfb125b62e1ed8f19d14b3e6c577cbe026386951..b7262e30dafb433e0b12d90f1f80ebc63a22927d 100644 (file)
--- a/src/librbd/deep_copy/SnapshotCopyRequest.cc
+++ b/src/librbd/deep_copy/SnapshotCopyRequest.cc
@@ -352,7 +352,7 @@ void SnapshotCopyRequest<I>::send_snap_create() {
         break;
       } else if (src_snap_id == m_src_snap_id_end) {
         // ... map it to destination HEAD since it's not a user snapshot that we
-        // will create (e.g. MirrorPrimarySnapshotNamespace)
+        // will create (e.g. MirrorSnapshotNamespace)
         m_snap_seqs[src_snap_id] = CEPH_NOSNAP;
       }
     }

diff --git a/src/librbd/image/PreRemoveRequest.cc b/src/librbd/image/PreRemoveRequest.cc
index 1a9d489d804edeee2bc434d3b31b5c77a6041a21..b8bf3692957063c7edf309da37c48507c49235d7 100644 (file)
--- a/src/librbd/image/PreRemoveRequest.cc
+++ b/src/librbd/image/PreRemoveRequest.cc
@@ -36,7 +36,7 @@ bool ignore_snapshot(const SnapInfo& snap_info) {
   auto snap_namespace_type = cls::rbd::get_snap_namespace_type(
     snap_info.snap_namespace);
   switch (snap_namespace_type) {
-  case cls::rbd::SNAPSHOT_NAMESPACE_TYPE_MIRROR_PRIMARY:
+  case cls::rbd::SNAPSHOT_NAMESPACE_TYPE_MIRROR:
   case cls::rbd::SNAPSHOT_NAMESPACE_TYPE_MIRROR_NON_PRIMARY:
     return true;
   default:

diff --git a/src/librbd/mirror/DisableRequest.cc b/src/librbd/mirror/DisableRequest.cc
index 500cebded8e6dcb483b8f8b503b612b9b712076c..16cdb34e5a3d235669293220a86af53b95787435 100644 (file)
--- a/src/librbd/mirror/DisableRequest.cc
+++ b/src/librbd/mirror/DisableRequest.cc
@@ -121,7 +121,7 @@ Context *DisableRequest<I>::handle_image_state_update(int *result) {
         auto &snap_info = it.second;
         auto type = cls::rbd::get_snap_namespace_type(
           snap_info.snap_namespace);
-        if (type == cls::rbd::SNAPSHOT_NAMESPACE_TYPE_MIRROR_PRIMARY ||
+        if (type == cls::rbd::SNAPSHOT_NAMESPACE_TYPE_MIRROR ||
             type == cls::rbd::SNAPSHOT_NAMESPACE_TYPE_MIRROR_NON_PRIMARY) {
           send_remove_snap("", snap_info.snap_namespace, snap_info.name);
           removing_snapshots = true;

diff --git a/src/librbd/mirror/GetInfoRequest.cc b/src/librbd/mirror/GetInfoRequest.cc
index 6ceb56f155bfdf5c4f17e43f49f98b6f26a0c90c..0dfd372ec75c50be5191506dbf604265a9ce19e3 100644 (file)
--- a/src/librbd/mirror/GetInfoRequest.cc
+++ b/src/librbd/mirror/GetInfoRequest.cc
@@ -250,16 +250,24 @@ void GetInfoRequest<I>::calc_promotion_state(
   *m_primary_mirror_uuid = "";
 
   for (auto it = snap_info.rbegin(); it != snap_info.rend(); it++) {
-    auto primary = boost::get<cls::rbd::MirrorPrimarySnapshotNamespace>(
+    auto mirror_ns = boost::get<cls::rbd::MirrorSnapshotNamespace>(
       &it->second.snap_namespace);
-    if (primary != nullptr) {
-      if (primary->demoted) {
-        *m_promotion_state = PROMOTION_STATE_ORPHAN;
-      } else {
+    if (mirror_ns != nullptr) {
+      switch (mirror_ns->state) {
+      case cls::rbd::MIRROR_SNAPSHOT_STATE_PRIMARY:
         *m_promotion_state = PROMOTION_STATE_PRIMARY;
+        break;
+      case cls::rbd::MIRROR_SNAPSHOT_STATE_NON_PRIMARY:
+        *m_promotion_state = PROMOTION_STATE_NON_PRIMARY;
+        break;
+      case cls::rbd::MIRROR_SNAPSHOT_STATE_PRIMARY_DEMOTED:
+      case cls::rbd::MIRROR_SNAPSHOT_STATE_NON_PRIMARY_DEMOTED:
+        *m_promotion_state = PROMOTION_STATE_ORPHAN;
+        break;
       }
       break;
     }
+
     auto non_primary =
       boost::get<cls::rbd::MirrorNonPrimarySnapshotNamespace>(
         &it->second.snap_namespace);
@@ -275,7 +283,7 @@ void GetInfoRequest<I>::calc_promotion_state(
   }
 
   ldout(m_cct, 10) << "promotion_state=" << *m_promotion_state << ", "
-                   << "primary_mirror_uuid=" << *m_promotion_state << dendl;
+                   << "primary_mirror_uuid=" << *m_primary_mirror_uuid << dendl;
 }
 
 } // namespace mirror

diff --git a/src/librbd/mirror/snapshot/CreatePrimaryRequest.cc b/src/librbd/mirror/snapshot/CreatePrimaryRequest.cc
index 4343935eafa801a5ea3b971f86a1402b2d1d2572..71b05623ddd05198f3ce01d6688150ea775a3ec0 100644 (file)
--- a/src/librbd/mirror/snapshot/CreatePrimaryRequest.cc
+++ b/src/librbd/mirror/snapshot/CreatePrimaryRequest.cc
@@ -110,8 +110,15 @@ void CreatePrimaryRequest<I>::create_snapshot() {
   CephContext *cct = m_image_ctx->cct;
   ldout(cct, 20) << dendl;
 
-  cls::rbd::MirrorPrimarySnapshotNamespace ns{
-    ((m_flags & CREATE_PRIMARY_FLAG_DEMOTED) != 0), m_mirror_peer_uuids};
+  cls::rbd::MirrorSnapshotNamespace ns{
+    ((m_flags & CREATE_PRIMARY_FLAG_DEMOTED) != 0 ?
+      cls::rbd::MIRROR_SNAPSHOT_STATE_PRIMARY_DEMOTED :
+      cls::rbd::MIRROR_SNAPSHOT_STATE_PRIMARY),
+    m_mirror_peer_uuids, "", CEPH_NOSNAP};
+
+  // TODO delay until after image state written
+  ns.complete = true;
+
   auto ctx = create_context_callback<
     CreatePrimaryRequest<I>,
     &CreatePrimaryRequest<I>::handle_create_snapshot>(this);
@@ -132,8 +139,15 @@ void CreatePrimaryRequest<I>::handle_create_snapshot(int r) {
 
   if (m_snap_id != nullptr) {
     std::shared_lock image_locker{m_image_ctx->image_lock};
-    cls::rbd::MirrorPrimarySnapshotNamespace ns{
-      ((m_flags & CREATE_PRIMARY_FLAG_DEMOTED) != 0), m_mirror_peer_uuids};
+    cls::rbd::MirrorSnapshotNamespace ns{
+      ((m_flags & CREATE_PRIMARY_FLAG_DEMOTED) != 0 ?
+        cls::rbd::MIRROR_SNAPSHOT_STATE_PRIMARY_DEMOTED :
+        cls::rbd::MIRROR_SNAPSHOT_STATE_PRIMARY),
+      m_mirror_peer_uuids, "", CEPH_NOSNAP};
+
+    // TODO delay until after image state written
+    ns.complete = true;
+
     *m_snap_id = m_image_ctx->get_snap_id(ns, m_snap_name);
   }
 
@@ -161,12 +175,12 @@ void CreatePrimaryRequest<I>::unlink_peer() {
         prev_snap_id = 0;
         continue;
       }
-      auto info = boost::get<cls::rbd::MirrorPrimarySnapshotNamespace>(
+      auto info = boost::get<cls::rbd::MirrorSnapshotNamespace>(
         &snap_it.second.snap_namespace);
       if (info == nullptr) {
         continue;
       }
-      if (info->demoted) {
+      if (info->state != cls::rbd::MIRROR_SNAPSHOT_STATE_PRIMARY) {
         // reset counters -- we count primary snapshots after the last promotion
         count = 0;
         prev_snap_id = 0;

diff --git a/src/librbd/mirror/snapshot/SetImageStateRequest.cc b/src/librbd/mirror/snapshot/SetImageStateRequest.cc
index d238664e2eefa10dea38e7d2c0c10de981c3c346..1d8e6ad4401b6fb5e6ee3afe098ec1b7eee6c3c4 100644 (file)
--- a/src/librbd/mirror/snapshot/SetImageStateRequest.cc
+++ b/src/librbd/mirror/snapshot/SetImageStateRequest.cc
@@ -127,7 +127,7 @@ void SetImageStateRequest<I>::handle_get_metadata(int r) {
 
     for (auto &[snap_id, snap_info] : m_image_ctx->snap_info) {
       auto type = cls::rbd::get_snap_namespace_type(snap_info.snap_namespace);
-      if (type == cls::rbd::SNAPSHOT_NAMESPACE_TYPE_MIRROR_PRIMARY ||
+      if (type == cls::rbd::SNAPSHOT_NAMESPACE_TYPE_MIRROR ||
           type == cls::rbd::SNAPSHOT_NAMESPACE_TYPE_MIRROR_NON_PRIMARY) {
         continue;
       }

diff --git a/src/librbd/mirror/snapshot/UnlinkPeerRequest.cc b/src/librbd/mirror/snapshot/UnlinkPeerRequest.cc
index 61d39e3a41e9811d6cb98d251082e6dba3fffa80..40fc0af55261519f6bc3a71a036186fae465afc1 100644 (file)
--- a/src/librbd/mirror/snapshot/UnlinkPeerRequest.cc
+++ b/src/librbd/mirror/snapshot/UnlinkPeerRequest.cc
@@ -69,7 +69,7 @@ void UnlinkPeerRequest<I>::unlink_peer() {
     return;
   }
 
-  auto info = boost::get<cls::rbd::MirrorPrimarySnapshotNamespace>(
+  auto info = boost::get<cls::rbd::MirrorSnapshotNamespace>(
     &snap_info->snap_namespace);
   if (info == nullptr) {
     lderr(cct) << "not mirror primary snapshot (snap_id=" << m_snap_id << ")"
@@ -169,7 +169,7 @@ void UnlinkPeerRequest<I>::remove_snapshot() {
     return;
   }
 
-  auto info = boost::get<cls::rbd::MirrorPrimarySnapshotNamespace>(
+  auto info = boost::get<cls::rbd::MirrorSnapshotNamespace>(
     &snap_namespace);
   ceph_assert(info);
 

diff --git a/src/librbd/mirror/snapshot/Utils.cc b/src/librbd/mirror/snapshot/Utils.cc
index 6f362f7e0c79e04ded0c7cb090628657fd80f91b..94a72c9964e4ad625709d1960384fe73365d8dd2 100644 (file)
--- a/src/librbd/mirror/snapshot/Utils.cc
+++ b/src/librbd/mirror/snapshot/Utils.cc
@@ -28,7 +28,7 @@ bool get_rollback_snap_id(
     uint64_t *rollback_snap_id) {
 
   for (; it != end; it++) {
-    auto primary = boost::get<cls::rbd::MirrorPrimarySnapshotNamespace>(
+    auto primary = boost::get<cls::rbd::MirrorSnapshotNamespace>(
       &it->second.snap_namespace);
     if (primary != nullptr) {
       break;
@@ -98,19 +98,55 @@ bool can_create_primary_snapshot(I *image_ctx, bool demoted, bool force,
       }
       return true;
     }
-    auto primary = boost::get<cls::rbd::MirrorPrimarySnapshotNamespace>(
+
+    auto mirror_ns = boost::get<cls::rbd::MirrorSnapshotNamespace>(
       &it->second.snap_namespace);
-    if (primary == nullptr) {
+    if (mirror_ns == nullptr) {
       continue;
     }
     ldout(cct, 20) << "previous snapshot snap_id=" << it->first << " "
-                   << *primary << dendl;
-    if (primary->demoted && !force) {
+                   << *mirror_ns << dendl;
+    if ((mirror_ns->state == cls::rbd::MIRROR_SNAPSHOT_STATE_PRIMARY_DEMOTED ||
+         mirror_ns->state ==
+           cls::rbd::MIRROR_SNAPSHOT_STATE_NON_PRIMARY_DEMOTED) &&
+        !force) {
       lderr(cct) << "trying to create primary snapshot without force "
                  << "when previous primary snapshot is demoted"
                  << dendl;
       return false;
     }
+
+    if (mirror_ns->state == cls::rbd::MIRROR_SNAPSHOT_STATE_NON_PRIMARY) {
+      if (!force) {
+        lderr(cct) << "trying to create primary snapshot without force "
+                   << "when previous snapshot is non-primary"
+                   << dendl;
+        return false;
+      }
+      if (demoted) {
+        lderr(cct) << "trying to create primary demoted snapshot "
+                   << "when previous snapshot is non-primary"
+                   << dendl;
+        return false;
+      }
+      if (!mirror_ns->complete) {
+        ldout(cct, 20) << "needs rollback" << dendl;
+        if (!rollback_snap_id) {
+          lderr(cct) << "trying to create primary snapshot "
+                     << "when previous non-primary snapshot is not copied yet"
+                     << dendl;
+          return false;
+        }
+        if (!get_rollback_snap_id(++it, image_ctx->snap_info.rend(),
+                                  rollback_snap_id)) {
+          lderr(cct) << "cannot rollback" << dendl;
+          return false;
+        }
+        ldout(cct, 20) << "rollback_snap_id=" << *rollback_snap_id << dendl;
+      }
+      return true;
+    }
+
     return true;
   }
 
@@ -126,12 +162,23 @@ bool can_create_non_primary_snapshot(I *image_ctx) {
 
   for (auto it = image_ctx->snap_info.rbegin();
        it != image_ctx->snap_info.rend(); it++) {
-    auto primary = boost::get<cls::rbd::MirrorPrimarySnapshotNamespace>(
+    auto mirror_ns = boost::get<cls::rbd::MirrorSnapshotNamespace>(
       &it->second.snap_namespace);
-    if (primary != nullptr) {
+    if (mirror_ns != nullptr) {
       ldout(cct, 20) << "previous mirror snapshot snap_id=" << it->first << " "
-                     << *primary << dendl;
-      if (!primary->demoted) {
+                     << *mirror_ns << dendl;
+
+      if (mirror_ns->state == cls::rbd::MIRROR_SNAPSHOT_STATE_NON_PRIMARY) {
+        if (!mirror_ns->complete) {
+          lderr(cct) << "trying to create non-primary snapshot "
+                     << "when previous non-primary snapshot is not copied yet"
+                     << dendl;
+          return false;
+        }
+        return true;
+      }
+
+      if (mirror_ns->state == cls::rbd::MIRROR_SNAPSHOT_STATE_PRIMARY) {
         lderr(cct) << "trying to create non-primary snapshot "
                    << "when previous primary snapshot is not in demoted state"
                    << dendl;
@@ -139,6 +186,7 @@ bool can_create_non_primary_snapshot(I *image_ctx) {
       }
       return true;
     }
+
     auto non_primary = boost::get<cls::rbd::MirrorNonPrimarySnapshotNamespace>(
       &it->second.snap_namespace);
     if (non_primary == nullptr) {

diff --git a/src/librbd/operation/SnapshotCreateRequest.cc b/src/librbd/operation/SnapshotCreateRequest.cc
index c0452458d46660d84e07027a25dd02039ab99a34..457e4014352f6a6fe1148eaa2b23342bd2f462e2 100644 (file)
--- a/src/librbd/operation/SnapshotCreateRequest.cc
+++ b/src/librbd/operation/SnapshotCreateRequest.cc
@@ -258,7 +258,7 @@ Context *SnapshotCreateRequest<I>::send_create_image_state() {
   I &image_ctx = this->m_image_ctx;
   auto type = cls::rbd::get_snap_namespace_type(m_snap_namespace);
 
-  if (type != cls::rbd::SNAPSHOT_NAMESPACE_TYPE_MIRROR_PRIMARY) {
+  if (type != cls::rbd::SNAPSHOT_NAMESPACE_TYPE_MIRROR) {
     update_snap_context();
     image_ctx.io_work_queue->unblock_writes();
     return this->create_context_finisher(0);

diff --git a/src/librbd/operation/SnapshotRemoveRequest.cc b/src/librbd/operation/SnapshotRemoveRequest.cc
index 0beec79bbda3eed103801feb6d3ff21f6485f49c..997b1c184a44071f7d84eea0e0b23883dbecfc41 100644 (file)
--- a/src/librbd/operation/SnapshotRemoveRequest.cc
+++ b/src/librbd/operation/SnapshotRemoveRequest.cc
@@ -357,7 +357,7 @@ void SnapshotRemoveRequest<I>::remove_image_state() {
   I &image_ctx = this->m_image_ctx;
   auto type = cls::rbd::get_snap_namespace_type(m_snap_namespace);
 
-  if (type != cls::rbd::SNAPSHOT_NAMESPACE_TYPE_MIRROR_PRIMARY &&
+  if (type != cls::rbd::SNAPSHOT_NAMESPACE_TYPE_MIRROR &&
       type != cls::rbd::SNAPSHOT_NAMESPACE_TYPE_MIRROR_NON_PRIMARY) {
     release_snap_id();
     return;

diff --git a/src/test/cls_rbd/test_cls_rbd.cc b/src/test/cls_rbd/test_cls_rbd.cc
index 7913bef6ed5003e0b02853680d30c3b302fac132..31f89356b748a31b7b41c5c5379b42575de2f0fa 100644 (file)
--- a/src/test/cls_rbd/test_cls_rbd.cc
+++ b/src/test/cls_rbd/test_cls_rbd.cc
@@ -2239,8 +2239,9 @@ TEST_F(TestClsRbd, mirror_snapshot) {
   string oid = get_temp_image_name();
   ASSERT_EQ(0, create_image(&ioctx, oid, 10, 22, 0, oid, -1));
 
-  cls::rbd::MirrorPrimarySnapshotNamespace primary = {false,
-                                                      {"peer1", "peer2"}};
+  cls::rbd::MirrorSnapshotNamespace primary = {
+    cls::rbd::MIRROR_SNAPSHOT_STATE_PRIMARY, {"peer1", "peer2"}, "",
+    CEPH_NOSNAP};
   cls::rbd::MirrorNonPrimarySnapshotNamespace non_primary = {"uuid", 123};
   librados::ObjectWriteOperation op;
   ::librbd::cls_client::snapshot_add(&op, 1, "primary", primary);
@@ -2249,7 +2250,7 @@ TEST_F(TestClsRbd, mirror_snapshot) {
 
   cls::rbd::SnapshotInfo snap;
   ASSERT_EQ(0, snapshot_get(&ioctx, oid, 1, &snap));
-  auto sn = boost::get<cls::rbd::MirrorPrimarySnapshotNamespace>(
+  auto sn = boost::get<cls::rbd::MirrorSnapshotNamespace>(
     &snap.snapshot_namespace);
   ASSERT_NE(nullptr, sn);
   ASSERT_EQ(primary, *sn);
@@ -2262,7 +2263,7 @@ TEST_F(TestClsRbd, mirror_snapshot) {
   ASSERT_EQ(-ENOENT, mirror_image_snapshot_unlink_peer(&ioctx, oid, 1,
                                                        "peer1"));
   ASSERT_EQ(0, snapshot_get(&ioctx, oid, 1, &snap));
-  sn = boost::get<cls::rbd::MirrorPrimarySnapshotNamespace>(
+  sn = boost::get<cls::rbd::MirrorSnapshotNamespace>(
     &snap.snapshot_namespace);
   ASSERT_NE(nullptr, sn);
   ASSERT_EQ(1U, sn->mirror_peer_uuids.size());
@@ -2271,7 +2272,7 @@ TEST_F(TestClsRbd, mirror_snapshot) {
   ASSERT_EQ(-ERESTART,
             mirror_image_snapshot_unlink_peer(&ioctx, oid, 1, "peer2"));
   ASSERT_EQ(0, snapshot_get(&ioctx, oid, 1, &snap));
-  sn = boost::get<cls::rbd::MirrorPrimarySnapshotNamespace>(
+  sn = boost::get<cls::rbd::MirrorSnapshotNamespace>(
     &snap.snapshot_namespace);
   ASSERT_NE(nullptr, sn);
   ASSERT_EQ(1U, sn->mirror_peer_uuids.size());

diff --git a/src/test/librbd/deep_copy/test_mock_SnapshotCopyRequest.cc b/src/test/librbd/deep_copy/test_mock_SnapshotCopyRequest.cc
index 4495fdc166efbc7469d86a666c768d7f56b2a9f9..40c282cd4cd70911f443901b83bfae0e53d37a01 100644 (file)
--- a/src/test/librbd/deep_copy/test_mock_SnapshotCopyRequest.cc
+++ b/src/test/librbd/deep_copy/test_mock_SnapshotCopyRequest.cc
@@ -859,8 +859,9 @@ TEST_F(TestMockDeepCopySnapshotCopyRequest, StartEndLimit) {
   ASSERT_EQ(0, create_snap(m_src_image_ctx, "snap1", false));
   ASSERT_EQ(0, create_snap(m_src_image_ctx, "snap2", false));
   ASSERT_EQ(0, create_snap(m_src_image_ctx,
-                           {cls::rbd::MirrorPrimarySnapshotNamespace{
-                              false, {{"peer uuid1"}}}},
+                           {cls::rbd::MirrorSnapshotNamespace{
+                              cls::rbd::MIRROR_SNAPSHOT_STATE_PRIMARY,
+                              {"peer uuid1"}, "", CEPH_NOSNAP}},
                            "snap3", false));
   auto src_snap_id1 = m_src_image_ctx->snaps[2];
   auto src_snap_id2 = m_src_image_ctx->snaps[1];

diff --git a/src/test/librbd/mirror/snapshot/test_mock_CreatePrimaryRequest.cc b/src/test/librbd/mirror/snapshot/test_mock_CreatePrimaryRequest.cc
index 8cab21ca9707e691ca78d23440fe62ec792ff7d6..5369fd46c8d75f3c41a562194846c3678323df4a 100644 (file)
--- a/src/test/librbd/mirror/snapshot/test_mock_CreatePrimaryRequest.cc
+++ b/src/test/librbd/mirror/snapshot/test_mock_CreatePrimaryRequest.cc
@@ -175,7 +175,7 @@ public:
                            auto it = mock_image_ctx.snap_info.find(snap_id);
                            ASSERT_NE(it, mock_image_ctx.snap_info.end());
                            auto info =
-                             boost::get<cls::rbd::MirrorPrimarySnapshotNamespace>(
+                             boost::get<cls::rbd::MirrorSnapshotNamespace>(
                                &it->second.snap_namespace);
                            ASSERT_NE(nullptr, info);
                            ASSERT_NE(0, info->mirror_peer_uuids.erase(
@@ -294,7 +294,8 @@ TEST_F(TestMockMirrorSnapshotCreatePrimaryRequest, SuccessUnlinkPeer) {
 
   MockTestImageCtx mock_image_ctx(*ictx);
   for (int i = 0; i < 3; i++) {
-    cls::rbd::MirrorPrimarySnapshotNamespace ns{false, {"uuid"}};
+    cls::rbd::MirrorSnapshotNamespace ns{
+      cls::rbd::MIRROR_SNAPSHOT_STATE_PRIMARY, {"uuid"}, "", CEPH_NOSNAP};
     snap_create(mock_image_ctx, ns, "mirror_snap");
   }
 

diff --git a/src/test/librbd/mirror/snapshot/test_mock_PromoteRequest.cc b/src/test/librbd/mirror/snapshot/test_mock_PromoteRequest.cc
index 76f73e5e0a0796453847cef8b4b680bbb9a6cf36..78954f183a567f694a728ac4c21b58bec365b976 100644 (file)
--- a/src/test/librbd/mirror/snapshot/test_mock_PromoteRequest.cc
+++ b/src/test/librbd/mirror/snapshot/test_mock_PromoteRequest.cc
@@ -302,7 +302,7 @@ TEST_F(TestMockMirrorSnapshotPromoteRequest, SuccessRollback) {
   expect_list_watchers(mock_image_ctx, mock_list_watchers_request, {}, 0);
   expect_acquire_lock(mock_image_ctx, 0);
 
-  SnapInfo snap_info = {"snap", cls::rbd::MirrorPrimarySnapshotNamespace{}, 0,
+  SnapInfo snap_info = {"snap", cls::rbd::MirrorSnapshotNamespace{}, 0,
                         {}, 0, 0, {}};
   expect_rollback(mock_image_ctx, 123, &snap_info, 0);
   MockCreatePrimaryRequest mock_create_primary_request;

diff --git a/src/test/librbd/mirror/snapshot/test_mock_UnlinkPeerRequest.cc b/src/test/librbd/mirror/snapshot/test_mock_UnlinkPeerRequest.cc
index 3c81aef865bf3c5789591b044b81d7e5d305293a..5de92de30d9bc4a02c1b18bb21161cad5df6b1db 100644 (file)
--- a/src/test/librbd/mirror/snapshot/test_mock_UnlinkPeerRequest.cc
+++ b/src/test/librbd/mirror/snapshot/test_mock_UnlinkPeerRequest.cc
@@ -91,7 +91,7 @@ public:
                            auto it = mock_image_ctx.snap_info.find(snap_id);
                            EXPECT_NE(it, mock_image_ctx.snap_info.end());
                            auto info =
-                             boost::get<cls::rbd::MirrorPrimarySnapshotNamespace>(
+                             boost::get<cls::rbd::MirrorSnapshotNamespace>(
                                &it->second.snap_namespace);
                            EXPECT_NE(nullptr, info);
                            EXPECT_NE(0, info->mirror_peer_uuids.erase(
@@ -132,7 +132,9 @@ TEST_F(TestMockMirrorSnapshotUnlinkPeerRequest, Success) {
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   MockTestImageCtx mock_image_ctx(*ictx);
-  cls::rbd::MirrorPrimarySnapshotNamespace ns{false, {"peer1_uuid", "peer2_uuid"}};
+  cls::rbd::MirrorSnapshotNamespace ns{
+    cls::rbd::MIRROR_SNAPSHOT_STATE_PRIMARY, {"peer1_uuid", "peer2_uuid"},
+    "", CEPH_NOSNAP};
   auto snap_id = snap_create(mock_image_ctx, ns, "mirror_snap");
 
   expect_get_snap_info(mock_image_ctx, snap_id);
@@ -159,7 +161,9 @@ TEST_F(TestMockMirrorSnapshotUnlinkPeerRequest, RemoveSnapshot) {
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   MockTestImageCtx mock_image_ctx(*ictx);
-  cls::rbd::MirrorPrimarySnapshotNamespace ns{false, {"peer_uuid"}};
+  cls::rbd::MirrorSnapshotNamespace ns{
+    cls::rbd::MIRROR_SNAPSHOT_STATE_PRIMARY, {"peer_uuid"},
+    "", CEPH_NOSNAP};
   auto snap_id = snap_create(mock_image_ctx, ns, "mirror_snap");
 
   expect_get_snap_info(mock_image_ctx, snap_id);
@@ -205,7 +209,9 @@ TEST_F(TestMockMirrorSnapshotUnlinkPeerRequest, PeerDNE) {
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   MockTestImageCtx mock_image_ctx(*ictx);
-  cls::rbd::MirrorPrimarySnapshotNamespace ns{false, {"peer_uuid"}};
+  cls::rbd::MirrorSnapshotNamespace ns{
+    cls::rbd::MIRROR_SNAPSHOT_STATE_PRIMARY, {"peer_uuid"},
+    "", CEPH_NOSNAP};
   auto snap_id = snap_create(mock_image_ctx, ns, "mirror_snap");
 
   expect_get_snap_info(mock_image_ctx, snap_id);
@@ -271,8 +277,9 @@ TEST_F(TestMockMirrorSnapshotUnlinkPeerRequest, UnlinkError) {
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   MockTestImageCtx mock_image_ctx(*ictx);
-  cls::rbd::MirrorPrimarySnapshotNamespace ns{false,
-                                              {"peer1_uuid", "peer2_uuid"}};
+  cls::rbd::MirrorSnapshotNamespace ns{
+    cls::rbd::MIRROR_SNAPSHOT_STATE_PRIMARY, {"peer1_uuid", "peer2_uuid"},
+    "", CEPH_NOSNAP};
   auto snap_id = snap_create(mock_image_ctx, ns, "mirror_snap");
 
   expect_get_snap_info(mock_image_ctx, snap_id);
@@ -296,8 +303,9 @@ TEST_F(TestMockMirrorSnapshotUnlinkPeerRequest, NotifyError) {
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   MockTestImageCtx mock_image_ctx(*ictx);
-  cls::rbd::MirrorPrimarySnapshotNamespace ns{false,
-                                              {"peer1_uuid", "peer2_uuid"}};
+  cls::rbd::MirrorSnapshotNamespace ns{
+    cls::rbd::MIRROR_SNAPSHOT_STATE_PRIMARY, {"peer1_uuid", "peer2_uuid"},
+    "", CEPH_NOSNAP};
   auto snap_id = snap_create(mock_image_ctx, ns, "mirror_snap");
 
   expect_get_snap_info(mock_image_ctx, snap_id);
@@ -322,7 +330,9 @@ TEST_F(TestMockMirrorSnapshotUnlinkPeerRequest, RemoveSnapshotError) {
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   MockTestImageCtx mock_image_ctx(*ictx);
-  cls::rbd::MirrorPrimarySnapshotNamespace ns{false, {"peer_uuid"}};
+  cls::rbd::MirrorSnapshotNamespace ns{
+    cls::rbd::MIRROR_SNAPSHOT_STATE_PRIMARY, {"peer_uuid"},
+    "", CEPH_NOSNAP};
   auto snap_id = snap_create(mock_image_ctx, ns, "mirror_snap");
 
   expect_get_snap_info(mock_image_ctx, snap_id);

diff --git a/src/test/librbd/mirror/snapshot/test_mock_Utils.cc b/src/test/librbd/mirror/snapshot/test_mock_Utils.cc
index 17752f0e5cd080da57b0599058bc25420c6bf8d4..a42f5ff30b3776b2a204ce6005df618f1e8c7fb4 100644 (file)
--- a/src/test/librbd/mirror/snapshot/test_mock_Utils.cc
+++ b/src/test/librbd/mirror/snapshot/test_mock_Utils.cc
@@ -88,7 +88,6 @@ TEST_F(TestMockMirrorSnapshotUtils, CanCreatePrimarySnapshot) {
   ASSERT_TRUE(util::can_create_primary_snapshot(&mock_image_ctx, false, true,
                                                 &rollback_snap_id));
   ASSERT_EQ(rollback_snap_id, CEPH_NOSNAP);
-  
 
   nns.copied = false;
   snap_create(mock_image_ctx, nns, "NPS2");
@@ -109,7 +108,8 @@ TEST_F(TestMockMirrorSnapshotUtils, CanCreatePrimarySnapshot) {
   ASSERT_TRUE(util::can_create_primary_snapshot(&mock_image_ctx, false, true,
                                                 nullptr));
 
-  cls::rbd::MirrorPrimarySnapshotNamespace pns{true, {"uuid"}};
+  cls::rbd::MirrorSnapshotNamespace pns{
+    cls::rbd::MIRROR_SNAPSHOT_STATE_PRIMARY_DEMOTED, {"uuid"}, "", CEPH_NOSNAP};
   snap_create(mock_image_ctx, pns, "PS1");
 
   // previous primary snapshot is demoted, no force
@@ -120,7 +120,7 @@ TEST_F(TestMockMirrorSnapshotUtils, CanCreatePrimarySnapshot) {
   ASSERT_TRUE(util::can_create_primary_snapshot(&mock_image_ctx, false, true,
                                                 nullptr));
 
-  pns.demoted = false;
+  pns.state = cls::rbd::MIRROR_SNAPSHOT_STATE_PRIMARY;
   snap_create(mock_image_ctx, pns, "PS2");
 
   // previous snapshot is not demoted primary
@@ -151,13 +151,14 @@ TEST_F(TestMockMirrorSnapshotUtils, CanCreateNonPrimarySnapshot) {
   // previous non-primary snapshot is copied
   ASSERT_TRUE(util::can_create_non_primary_snapshot(&mock_image_ctx));
 
-  cls::rbd::MirrorPrimarySnapshotNamespace pns{false, {"uuid"}};
+  cls::rbd::MirrorSnapshotNamespace pns{
+    cls::rbd::MIRROR_SNAPSHOT_STATE_PRIMARY, {"uuid"}, "", CEPH_NOSNAP};
   snap_create(mock_image_ctx, pns, "PS1");
 
   // previous primary snapshot is not in demoted state
   ASSERT_FALSE(util::can_create_non_primary_snapshot(&mock_image_ctx));
 
-  pns.demoted = true;
+  pns.state = cls::rbd::MIRROR_SNAPSHOT_STATE_NON_PRIMARY_DEMOTED;
   snap_create(mock_image_ctx, pns, "PS2");
 
   // previous primary snapshot is in demoted state

diff --git a/src/test/librbd/operation/test_mock_SnapshotCreateRequest.cc b/src/test/librbd/operation/test_mock_SnapshotCreateRequest.cc
index 42152157f24d081e2daaa7542aaae74866505d16..da7c6492ef5beca92f2872a0482a57c544a7b8b9 100644 (file)
--- a/src/test/librbd/operation/test_mock_SnapshotCreateRequest.cc
+++ b/src/test/librbd/operation/test_mock_SnapshotCreateRequest.cc
@@ -381,7 +381,7 @@ TEST_F(TestMockOperationSnapshotCreateRequest, SetImageState) {
 
   C_SaferCond cond_ctx;
   MockSnapshotCreateRequest *req = new MockSnapshotCreateRequest(
-    mock_image_ctx, &cond_ctx, cls::rbd::MirrorPrimarySnapshotNamespace(),
+    mock_image_ctx, &cond_ctx, cls::rbd::MirrorSnapshotNamespace(),
       "snap1", 0, false);
   {
     std::shared_lock owner_locker{mock_image_ctx.owner_lock};

diff --git a/src/test/librbd/operation/test_mock_SnapshotRemoveRequest.cc b/src/test/librbd/operation/test_mock_SnapshotRemoveRequest.cc
index 2139496cc3b5e4492000a09d9347cd45d15b1c6e..208998b5eac426dffa9c22b5654cf09ac7d85164 100644 (file)
--- a/src/test/librbd/operation/test_mock_SnapshotRemoveRequest.cc
+++ b/src/test/librbd/operation/test_mock_SnapshotRemoveRequest.cc
@@ -512,7 +512,7 @@ TEST_F(TestMockOperationSnapshotRemoveRequest, MirrorSnapshot) {
 
   uint64_t snap_id = ictx->snap_info.rbegin()->first;
   expect_snapshot_get(mock_image_ctx,
-                      {snap_id, {cls::rbd::MirrorPrimarySnapshotNamespace{}},
+                      {snap_id, {cls::rbd::MirrorSnapshotNamespace{}},
                        "mirror", 123, {}, 0}, 0);
 
   expect_get_parent_spec(mock_image_ctx, 0);
@@ -525,7 +525,7 @@ TEST_F(TestMockOperationSnapshotRemoveRequest, MirrorSnapshot) {
 
   C_SaferCond cond_ctx;
   MockSnapshotRemoveRequest *req = new MockSnapshotRemoveRequest(
-    mock_image_ctx, &cond_ctx, cls::rbd::MirrorPrimarySnapshotNamespace(),
+    mock_image_ctx, &cond_ctx, cls::rbd::MirrorSnapshotNamespace(),
     "mirror", snap_id);
   {
     std::shared_lock owner_locker{mock_image_ctx.owner_lock};