librbd: drop MirrorNonPrimarySnapshotNamespace

The required fields (and state enum) have already been added to the
MirrorSnapshotNamespace. This drops the namespace and tweaks existing
code to use it.

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 f311137da6add0e28bd196b89f03752e3dd42d93..6e7cfbd2ee091211fcf8c385107773256054e173 100644 (file)
--- a/src/cls/rbd/cls_rbd.cc
+++ b/src/cls/rbd/cls_rbd.cc
@@ -5711,7 +5711,7 @@ int image_snapshot_unlink_peer(cls_method_context_t hctx,
 }
 
 int image_snapshot_set_copy_progress(cls_method_context_t hctx,
-                                     uint64_t snap_id, bool copied,
+                                     uint64_t snap_id, bool complete,
                                      uint64_t last_copied_object_number) {
   cls_rbd_snap snap;
   std::string snap_key;
@@ -5725,16 +5725,19 @@ int image_snapshot_set_copy_progress(cls_method_context_t hctx,
     return r;
   }
 
-  auto non_primary = boost::get<cls::rbd::MirrorNonPrimarySnapshotNamespace>(
+  auto mirror_ns = boost::get<cls::rbd::MirrorSnapshotNamespace>(
     &snap.snapshot_namespace);
-  if (non_primary == nullptr) {
+  if (mirror_ns == nullptr) {
     CLS_LOG(5, "mirror_image_snapshot_set_copy_progress " \
             "not mirroring snapshot snap_id=%" PRIu64, snap_id);
     return -EINVAL;
   }
 
-  non_primary->copied = copied;
-  non_primary->last_copied_object_number = last_copied_object_number;
+  mirror_ns->complete = complete;
+  if (mirror_ns->state == cls::rbd::MIRROR_SNAPSHOT_STATE_NON_PRIMARY ||
+      mirror_ns->state == cls::rbd::MIRROR_SNAPSHOT_STATE_NON_PRIMARY_DEMOTED) {
+    mirror_ns->last_copied_object_number = last_copied_object_number;
+  }
 
   r = image::snapshot::write(hctx, snap_key, std::move(snap));
   if (r < 0) {
@@ -6760,7 +6763,7 @@ int mirror_image_snapshot_unlink_peer(cls_method_context_t hctx, bufferlist *in,
 /**
  * Input:
  * @param snap_id: snapshot id
- * @param copied: true if shapshot fully copied
+ * @param complete: true if shapshot fully copied/complete
  * @param last_copied_object_number: last copied object number
  *
  * Output:
@@ -6770,22 +6773,22 @@ int mirror_image_snapshot_set_copy_progress(cls_method_context_t hctx,
                                             bufferlist *in,
                                             bufferlist *out) {
   uint64_t snap_id;
-  bool copied;
+  bool complete;
   uint64_t last_copied_object_number;
   try {
     auto iter = in->cbegin();
     decode(snap_id, iter);
-    decode(copied, iter);
+    decode(complete, iter);
     decode(last_copied_object_number, iter);
   } catch (const buffer::error &err) {
     return -EINVAL;
   }
 
   CLS_LOG(20, "mirror_image_snapshot_set_copy_progress snap_id=%" PRIu64 \
-          " copied=%d last_copied_object_number=%" PRIu64, snap_id, copied,
+          " complete=%d last_copied_object_number=%" PRIu64, snap_id, complete,
           last_copied_object_number);
 
-  int r = mirror::image_snapshot_set_copy_progress(hctx, snap_id, copied,
+  int r = mirror::image_snapshot_set_copy_progress(hctx, snap_id, complete,
                                                    last_copied_object_number);
   if (r < 0) {
     return r;

diff --git a/src/cls/rbd/cls_rbd_client.cc b/src/cls/rbd/cls_rbd_client.cc
index 5b39ab81e4cbc8c07bd9aba4306d6061f04c685f..808569b1ed53cdb0a39c8ecf1af561c3b2a63fd2 100644 (file)
--- a/src/cls/rbd/cls_rbd_client.cc
+++ b/src/cls/rbd/cls_rbd_client.cc
@@ -2477,11 +2477,11 @@ int mirror_image_snapshot_unlink_peer(librados::IoCtx *ioctx,
 }
 
 void mirror_image_snapshot_set_copy_progress(librados::ObjectWriteOperation *op,
-                                             snapid_t snap_id, bool copied,
+                                             snapid_t snap_id, bool complete,
                                              uint64_t copy_progress) {
   bufferlist bl;
   encode(snap_id, bl);
-  encode(copied, bl);
+  encode(complete, bl);
   encode(copy_progress, bl);
 
   op->exec("rbd", "mirror_image_snapshot_set_copy_progress", bl);
@@ -2489,10 +2489,11 @@ void mirror_image_snapshot_set_copy_progress(librados::ObjectWriteOperation *op,
 
 int mirror_image_snapshot_set_copy_progress(librados::IoCtx *ioctx,
                                             const std::string &oid,
-                                            snapid_t snap_id, bool copied,
+                                            snapid_t snap_id, bool complete,
                                             uint64_t copy_progress) {
   librados::ObjectWriteOperation op;
-  mirror_image_snapshot_set_copy_progress(&op, snap_id, copied, copy_progress);
+  mirror_image_snapshot_set_copy_progress(&op, snap_id, complete,
+                                          copy_progress);
   return ioctx->operate(oid, &op);
 }
 

diff --git a/src/cls/rbd/cls_rbd_client.h b/src/cls/rbd/cls_rbd_client.h
index 0a0e1617f17e8b4bc2cfe8582a732176b87b8f36..ba9d94bb136f19386af59e9a646b3ed87eca6cbf 100644 (file)
--- a/src/cls/rbd/cls_rbd_client.h
+++ b/src/cls/rbd/cls_rbd_client.h
@@ -529,11 +529,11 @@ int mirror_image_snapshot_unlink_peer(librados::IoCtx *ioctx,
                                       snapid_t snap_id,
                                       const std::string &mirror_peer_uuid);
 void mirror_image_snapshot_set_copy_progress(librados::ObjectWriteOperation *op,
-                                             snapid_t snap_id, bool copied,
+                                             snapid_t snap_id, bool complete,
                                              uint64_t copy_progress);
 int mirror_image_snapshot_set_copy_progress(librados::IoCtx *ioctx,
                                             const std::string &oid,
-                                            snapid_t snap_id, bool copied,
+                                            snapid_t snap_id, bool complete,
                                             uint64_t copy_progress);
 
 // Groups functions

diff --git a/src/cls/rbd/cls_rbd_types.cc b/src/cls/rbd/cls_rbd_types.cc
index 160d89391b9f32707b921ee62fc53d5b45135efe..57e919faf18eb5fb7a088d68aed092224ef0396f 100644 (file)
--- a/src/cls/rbd/cls_rbd_types.cc
+++ b/src/cls/rbd/cls_rbd_types.cc
@@ -754,32 +754,6 @@ void MirrorSnapshotNamespace::dump(Formatter *f) const {
   f->dump_stream("snap_seqs") << snap_seqs;
 }
 
-void MirrorNonPrimarySnapshotNamespace::encode(bufferlist& bl) const {
-  using ceph::encode;
-  encode(primary_mirror_uuid, bl);
-  encode(primary_snap_id, bl);
-  encode(copied, bl);
-  encode(last_copied_object_number, bl);
-  encode(snap_seqs, bl);
-}
-
-void MirrorNonPrimarySnapshotNamespace::decode(bufferlist::const_iterator& it) {
-  using ceph::decode;
-  decode(primary_mirror_uuid, it);
-  decode(primary_snap_id, it);
-  decode(copied, it);
-  decode(last_copied_object_number, it);
-  decode(snap_seqs, it);
-}
-
-void MirrorNonPrimarySnapshotNamespace::dump(Formatter *f) const {
-  f->dump_string("primary_mirror_uuid", primary_mirror_uuid);
-  f->dump_unsigned("primary_snap_id", primary_snap_id);
-  f->dump_bool("copied", copied);
-  f->dump_unsigned("last_copied_object_number", last_copied_object_number);
-  f->dump_stream("snap_seqs") << snap_seqs;
-}
-
 class EncodeSnapshotNamespaceVisitor : public boost::static_visitor<void> {
 public:
   explicit EncodeSnapshotNamespaceVisitor(bufferlist &bl) : m_bl(bl) {
@@ -891,9 +865,6 @@ void SnapshotInfo::generate_test_instances(std::list<SnapshotInfo*> &o) {
                                MirrorSnapshotNamespace{MIRROR_SNAPSHOT_STATE_NON_PRIMARY,
                                                        {"1", "2"}, "uuid", 123},
                                "snap1", 123, {123456, 0}, 12));
-  o.push_back(new SnapshotInfo(1ULL,
-                               MirrorNonPrimarySnapshotNamespace{"uuid", 111},
-                               "snap1", 123, {123456, 0}, 12));
 }
 
 void SnapshotNamespace::encode(bufferlist& bl) const {
@@ -920,9 +891,6 @@ void SnapshotNamespace::decode(bufferlist::const_iterator &p)
     case cls::rbd::SNAPSHOT_NAMESPACE_TYPE_MIRROR:
       *this = MirrorSnapshotNamespace();
       break;
-    case cls::rbd::SNAPSHOT_NAMESPACE_TYPE_MIRROR_NON_PRIMARY:
-      *this = MirrorNonPrimarySnapshotNamespace();
-      break;
     default:
       *this = UnknownSnapshotNamespace();
       break;
@@ -955,7 +923,6 @@ void SnapshotNamespace::generate_test_instances(std::list<SnapshotNamespace*> &o
   o.push_back(new SnapshotNamespace(MirrorSnapshotNamespace(MIRROR_SNAPSHOT_STATE_NON_PRIMARY_DEMOTED,
                                                             {"peer uuid"},
                                                             "uuid", 123)));
-  o.push_back(new SnapshotNamespace(MirrorNonPrimarySnapshotNamespace("", 0)));
 }
 
 std::ostream& operator<<(std::ostream& os, const SnapshotNamespaceType& type) {
@@ -972,9 +939,6 @@ std::ostream& operator<<(std::ostream& os, const SnapshotNamespaceType& type) {
   case SNAPSHOT_NAMESPACE_TYPE_MIRROR:
     os << "mirror";
     break;
-  case SNAPSHOT_NAMESPACE_TYPE_MIRROR_NON_PRIMARY:
-    os << "mirror_non_primary";
-    break;
   default:
     os << "unknown";
     break;
@@ -1016,18 +980,6 @@ std::ostream& operator<<(std::ostream& os, const MirrorSnapshotNamespace& ns) {
   return os;
 }
 
-std::ostream& operator<<(std::ostream& os,
-                         const MirrorNonPrimarySnapshotNamespace& ns) {
-  os << "[" << SNAPSHOT_NAMESPACE_TYPE_MIRROR_NON_PRIMARY << " "
-     << "primary_mirror_uuid=" << ns.primary_mirror_uuid << ", "
-     << "primary_snap_id=" << ns.primary_snap_id << ", "
-     << "copied=" << ns.copied << ", "
-     << "last_copied_object_number=" << ns.last_copied_object_number << ", "
-     << "snap_seqs=" << ns.snap_seqs
-     << "]";
-  return os;
-}
-
 std::ostream& operator<<(std::ostream& os, const UnknownSnapshotNamespace& ns) {
   os << "[unknown]";
   return os;
@@ -1052,7 +1004,6 @@ std::ostream& operator<<(std::ostream& os, MirrorSnapshotState type) {
     break;
   }
   return os;
-
 }
 
 void ImageSnapshotSpec::encode(bufferlist& bl) const {

diff --git a/src/cls/rbd/cls_rbd_types.h b/src/cls/rbd/cls_rbd_types.h
index d1d21ef067539233932d03328a179419b7840bae..18c7b0350fe977dcca6efe60c87dd41a283999c1 100644 (file)
--- a/src/cls/rbd/cls_rbd_types.h
+++ b/src/cls/rbd/cls_rbd_types.h
@@ -417,11 +417,10 @@ struct GroupSpec {
 WRITE_CLASS_ENCODER(GroupSpec);
 
 enum SnapshotNamespaceType {
-  SNAPSHOT_NAMESPACE_TYPE_USER               = 0,
-  SNAPSHOT_NAMESPACE_TYPE_GROUP              = 1,
-  SNAPSHOT_NAMESPACE_TYPE_TRASH              = 2,
-  SNAPSHOT_NAMESPACE_TYPE_MIRROR             = 3,
-  SNAPSHOT_NAMESPACE_TYPE_MIRROR_NON_PRIMARY = 4,
+  SNAPSHOT_NAMESPACE_TYPE_USER   = 0,
+  SNAPSHOT_NAMESPACE_TYPE_GROUP  = 1,
+  SNAPSHOT_NAMESPACE_TYPE_TRASH  = 2,
+  SNAPSHOT_NAMESPACE_TYPE_MIRROR = 3,
 };
 
 struct UserSnapshotNamespace {
@@ -606,49 +605,6 @@ struct MirrorSnapshotNamespace {
   }
 };
 
-struct MirrorNonPrimarySnapshotNamespace {
-  static const SnapshotNamespaceType SNAPSHOT_NAMESPACE_TYPE =
-    SNAPSHOT_NAMESPACE_TYPE_MIRROR_NON_PRIMARY;
-
-  std::string primary_mirror_uuid;
-  snapid_t primary_snap_id = CEPH_NOSNAP;
-  bool copied = false;
-  uint64_t last_copied_object_number = 0;
-  SnapSeqs snap_seqs;
-
-  MirrorNonPrimarySnapshotNamespace() {
-  }
-  MirrorNonPrimarySnapshotNamespace(const std::string &primary_mirror_uuid,
-                                    snapid_t primary_snap_id)
-    : primary_mirror_uuid(primary_mirror_uuid),
-      primary_snap_id(primary_snap_id) {
-  }
-
-  void encode(bufferlist& bl) const;
-  void decode(bufferlist::const_iterator& it);
-
-  void dump(Formatter *f) const;
-
-  inline bool operator==(const MirrorNonPrimarySnapshotNamespace& mnsn) const {
-    return primary_mirror_uuid == mnsn.primary_mirror_uuid &&
-           primary_snap_id == mnsn.primary_snap_id && copied == mnsn.copied &&
-           last_copied_object_number == mnsn.last_copied_object_number;
-  }
-
-  inline bool operator<(const MirrorNonPrimarySnapshotNamespace& mnsn) const {
-    if (primary_mirror_uuid != mnsn.primary_mirror_uuid) {
-      return primary_mirror_uuid < mnsn.primary_mirror_uuid;
-    }
-    if (primary_snap_id != mnsn.primary_snap_id) {
-      return primary_snap_id < mnsn.primary_snap_id;
-    }
-    if (copied != mnsn.copied) {
-      return copied < mnsn.copied;
-    }
-    return last_copied_object_number < mnsn.last_copied_object_number;
-  }
-};
-
 struct UnknownSnapshotNamespace {
   static const SnapshotNamespaceType SNAPSHOT_NAMESPACE_TYPE =
     static_cast<SnapshotNamespaceType>(-1);
@@ -673,15 +629,12 @@ 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 MirrorSnapshotNamespace& ns);
-std::ostream& operator<<(std::ostream& os,
-                         const MirrorNonPrimarySnapshotNamespace& ns);
 std::ostream& operator<<(std::ostream& os, const UnknownSnapshotNamespace& ns);
 
 typedef boost::variant<UserSnapshotNamespace,
                        GroupSnapshotNamespace,
                        TrashSnapshotNamespace,
                        MirrorSnapshotNamespace,
-                       MirrorNonPrimarySnapshotNamespace,
                        UnknownSnapshotNamespace> SnapshotNamespaceVariant;
 
 struct SnapshotNamespace : public SnapshotNamespaceVariant {

diff --git a/src/librbd/api/Snapshot.cc b/src/librbd/api/Snapshot.cc
index bc815341b3709136b0ef4264aad5551efd87fa92..da6c7196bc83aba938fb085e85fb6caf548ba8f6 100644 (file)
--- a/src/librbd/api/Snapshot.cc
+++ b/src/librbd/api/Snapshot.cc
@@ -123,17 +123,6 @@ public:
       snap_namespace.last_copied_object_number;
     return 0;
   }
-
-  inline int operator()(
-      const cls::rbd::MirrorNonPrimarySnapshotNamespace& snap_namespace) {
-    mirror_snap->state = RBD_SNAP_MIRROR_STATE_NON_PRIMARY;
-    mirror_snap->primary_mirror_uuid = snap_namespace.primary_mirror_uuid;
-    mirror_snap->primary_snap_id = snap_namespace.primary_snap_id;
-    mirror_snap->complete = snap_namespace.copied;
-    mirror_snap->last_copied_object_number =
-      snap_namespace.last_copied_object_number;
-    return 0;
-  }
 };
 
 } // anonymous namespace

diff --git a/src/librbd/image/PreRemoveRequest.cc b/src/librbd/image/PreRemoveRequest.cc
index b8bf3692957063c7edf309da37c48507c49235d7..ccd2e369dd6ac6fa086e2bc477b41bfb19996fe6 100644 (file)
--- a/src/librbd/image/PreRemoveRequest.cc
+++ b/src/librbd/image/PreRemoveRequest.cc
@@ -37,7 +37,6 @@ bool ignore_snapshot(const SnapInfo& snap_info) {
     snap_info.snap_namespace);
   switch (snap_namespace_type) {
   case cls::rbd::SNAPSHOT_NAMESPACE_TYPE_MIRROR:
-  case cls::rbd::SNAPSHOT_NAMESPACE_TYPE_MIRROR_NON_PRIMARY:
     return true;
   default:
     return false;

diff --git a/src/librbd/mirror/DisableRequest.cc b/src/librbd/mirror/DisableRequest.cc
index 16cdb34e5a3d235669293220a86af53b95787435..4a7d914fce4db59ad2dcfd5ada9672020107e819 100644 (file)
--- a/src/librbd/mirror/DisableRequest.cc
+++ b/src/librbd/mirror/DisableRequest.cc
@@ -121,8 +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 ||
-            type == cls::rbd::SNAPSHOT_NAMESPACE_TYPE_MIRROR_NON_PRIMARY) {
+        if (type == cls::rbd::SNAPSHOT_NAMESPACE_TYPE_MIRROR) {
           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 0dfd372ec75c50be5191506dbf604265a9ce19e3..c264dec03a8591f68c0d3e010d49459cfc784092 100644 (file)
--- a/src/librbd/mirror/GetInfoRequest.cc
+++ b/src/librbd/mirror/GetInfoRequest.cc
@@ -267,19 +267,6 @@ void GetInfoRequest<I>::calc_promotion_state(
       }
       break;
     }
-
-    auto non_primary =
-      boost::get<cls::rbd::MirrorNonPrimarySnapshotNamespace>(
-        &it->second.snap_namespace);
-    if (non_primary != nullptr) {
-      if (non_primary->primary_mirror_uuid.empty()) {
-        *m_promotion_state = PROMOTION_STATE_ORPHAN;
-      } else {
-        *m_promotion_state = PROMOTION_STATE_NON_PRIMARY;
-        *m_primary_mirror_uuid = non_primary->primary_mirror_uuid;
-      }
-      break;
-    }
   }
 
   ldout(m_cct, 10) << "promotion_state=" << *m_promotion_state << ", "

diff --git a/src/librbd/mirror/snapshot/CreateNonPrimaryRequest.cc b/src/librbd/mirror/snapshot/CreateNonPrimaryRequest.cc
index 21f821f3d5f0544852e064da7b15e837162cc723..38c39c71e2a6b7fcfa6f5f9224b89b5585fb9adb 100644 (file)
--- a/src/librbd/mirror/snapshot/CreateNonPrimaryRequest.cc
+++ b/src/librbd/mirror/snapshot/CreateNonPrimaryRequest.cc
@@ -118,8 +118,9 @@ void CreateNonPrimaryRequest<I>::create_snapshot() {
   CephContext *cct = m_image_ctx->cct;
   ldout(cct, 20) << dendl;
 
-  cls::rbd::MirrorNonPrimarySnapshotNamespace ns{m_primary_mirror_uuid,
-                                                 m_primary_snap_id};
+  cls::rbd::MirrorSnapshotNamespace ns{
+    cls::rbd::MIRROR_SNAPSHOT_STATE_NON_PRIMARY, {},
+    m_primary_mirror_uuid, m_primary_snap_id};
   auto ctx = create_context_callback<
     CreateNonPrimaryRequest<I>,
     &CreateNonPrimaryRequest<I>::handle_create_snapshot>(this);
@@ -146,8 +147,9 @@ void CreateNonPrimaryRequest<I>::write_image_state() {
   uint64_t snap_id;
   {
     std::shared_lock image_locker{m_image_ctx->image_lock};
-    cls::rbd::MirrorNonPrimarySnapshotNamespace ns{m_primary_mirror_uuid,
-                                                   m_primary_snap_id};
+    cls::rbd::MirrorSnapshotNamespace ns{
+      cls::rbd::MIRROR_SNAPSHOT_STATE_NON_PRIMARY, {},
+      m_primary_mirror_uuid, m_primary_snap_id};
     snap_id = m_image_ctx->get_snap_id(ns, m_snap_name);
   }
 

diff --git a/src/librbd/mirror/snapshot/CreatePrimaryRequest.cc b/src/librbd/mirror/snapshot/CreatePrimaryRequest.cc
index 71b05623ddd05198f3ce01d6688150ea775a3ec0..3aa171b4002ae5d916cbaee9d8a328f08e935d6b 100644 (file)
--- a/src/librbd/mirror/snapshot/CreatePrimaryRequest.cc
+++ b/src/librbd/mirror/snapshot/CreatePrimaryRequest.cc
@@ -168,13 +168,6 @@ void CreatePrimaryRequest<I>::unlink_peer() {
     size_t count = 0;
     uint64_t prev_snap_id = 0;
     for (auto &snap_it : m_image_ctx->snap_info) {
-      if (boost::get<cls::rbd::MirrorNonPrimarySnapshotNamespace>(
-            &snap_it.second.snap_namespace)) {
-        // reset counters -- we count primary snapshots after the last promotion
-        count = 0;
-        prev_snap_id = 0;
-        continue;
-      }
       auto info = boost::get<cls::rbd::MirrorSnapshotNamespace>(
         &snap_it.second.snap_namespace);
       if (info == nullptr) {

diff --git a/src/librbd/mirror/snapshot/SetImageStateRequest.cc b/src/librbd/mirror/snapshot/SetImageStateRequest.cc
index 1d8e6ad4401b6fb5e6ee3afe098ec1b7eee6c3c4..8e2c804a2911ff7c02af33b8cd71a9b44a34a2e3 100644 (file)
--- a/src/librbd/mirror/snapshot/SetImageStateRequest.cc
+++ b/src/librbd/mirror/snapshot/SetImageStateRequest.cc
@@ -127,8 +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 ||
-          type == cls::rbd::SNAPSHOT_NAMESPACE_TYPE_MIRROR_NON_PRIMARY) {
+      if (type == cls::rbd::SNAPSHOT_NAMESPACE_TYPE_MIRROR) {
         continue;
       }
       m_image_state.snapshots[snap_id] = {snap_id, snap_info.snap_namespace,

diff --git a/src/librbd/mirror/snapshot/Utils.cc b/src/librbd/mirror/snapshot/Utils.cc
index 94a72c9964e4ad625709d1960384fe73365d8dd2..6081be8c405e9d2584165014384ba3a5b16d3e83 100644 (file)
--- a/src/librbd/mirror/snapshot/Utils.cc
+++ b/src/librbd/mirror/snapshot/Utils.cc
@@ -28,15 +28,12 @@ bool get_rollback_snap_id(
     uint64_t *rollback_snap_id) {
 
   for (; it != end; it++) {
-    auto primary = boost::get<cls::rbd::MirrorSnapshotNamespace>(
+    auto mirror_ns = boost::get<cls::rbd::MirrorSnapshotNamespace>(
       &it->second.snap_namespace);
-    if (primary != nullptr) {
+    if (mirror_ns->state != cls::rbd::MIRROR_SNAPSHOT_STATE_NON_PRIMARY) {
       break;
     }
-
-    auto non_primary = boost::get<cls::rbd::MirrorNonPrimarySnapshotNamespace>(
-      &it->second.snap_namespace);
-    if (non_primary->copied) {
+    if (mirror_ns->complete) {
       break;
     }
   }
@@ -64,41 +61,6 @@ bool can_create_primary_snapshot(I *image_ctx, bool demoted, bool force,
 
   for (auto it = image_ctx->snap_info.rbegin();
        it != image_ctx->snap_info.rend(); it++) {
-    auto non_primary = boost::get<cls::rbd::MirrorNonPrimarySnapshotNamespace>(
-      &it->second.snap_namespace);
-    if (non_primary != nullptr) {
-      ldout(cct, 20) << "previous mirror snapshot snap_id=" << it->first << " "
-                     << *non_primary << dendl;
-      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 (!non_primary->primary_mirror_uuid.empty() && !non_primary->copied) {
-        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;
-    }
-
     auto mirror_ns = boost::get<cls::rbd::MirrorSnapshotNamespace>(
       &it->second.snap_namespace);
     if (mirror_ns == nullptr) {
@@ -186,21 +148,6 @@ 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) {
-      continue;
-    }
-    ldout(cct, 20) << "previous snapshot snap_id=" << it->first << " "
-                   << *non_primary << dendl;
-    if (!non_primary->copied) {
-      lderr(cct) << "trying to create non-primary snapshot "
-                 << "when previous non-primary snapshot is not copied yet"
-                 << dendl;
-      return false;
-    }
-    return true;
   }
 
   ldout(cct, 20) << "no previous mirror snapshots found" << dendl;

diff --git a/src/librbd/operation/SnapshotRemoveRequest.cc b/src/librbd/operation/SnapshotRemoveRequest.cc
index 997b1c184a44071f7d84eea0e0b23883dbecfc41..b78be8a0af6bb4fb403d52a9139ea31d263d5ca3 100644 (file)
--- a/src/librbd/operation/SnapshotRemoveRequest.cc
+++ b/src/librbd/operation/SnapshotRemoveRequest.cc
@@ -357,8 +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 &&
-      type != cls::rbd::SNAPSHOT_NAMESPACE_TYPE_MIRROR_NON_PRIMARY) {
+  if (type != cls::rbd::SNAPSHOT_NAMESPACE_TYPE_MIRROR) {
     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 31f89356b748a31b7b41c5c5379b42575de2f0fa..f6a59ffd8c810f76668b7680223934b73cc76cca 100644 (file)
--- a/src/test/cls_rbd/test_cls_rbd.cc
+++ b/src/test/cls_rbd/test_cls_rbd.cc
@@ -2242,7 +2242,8 @@ TEST_F(TestClsRbd, mirror_snapshot) {
   cls::rbd::MirrorSnapshotNamespace primary = {
     cls::rbd::MIRROR_SNAPSHOT_STATE_PRIMARY, {"peer1", "peer2"}, "",
     CEPH_NOSNAP};
-  cls::rbd::MirrorNonPrimarySnapshotNamespace non_primary = {"uuid", 123};
+  cls::rbd::MirrorSnapshotNamespace non_primary = {
+    cls::rbd::MIRROR_SNAPSHOT_STATE_NON_PRIMARY, {}, "uuid", 123};
   librados::ObjectWriteOperation op;
   ::librbd::cls_client::snapshot_add(&op, 1, "primary", primary);
   ::librbd::cls_client::snapshot_add(&op, 2, "non_primary", non_primary);
@@ -2279,20 +2280,20 @@ TEST_F(TestClsRbd, mirror_snapshot) {
   ASSERT_EQ(1U, sn->mirror_peer_uuids.count("peer2"));
 
   ASSERT_EQ(0, snapshot_get(&ioctx, oid, 2, &snap));
-  auto nsn = boost::get<cls::rbd::MirrorNonPrimarySnapshotNamespace>(
+  auto nsn = boost::get<cls::rbd::MirrorSnapshotNamespace>(
     &snap.snapshot_namespace);
   ASSERT_NE(nullptr, nsn);
   ASSERT_EQ(non_primary, *nsn);
-  ASSERT_FALSE(nsn->copied);
+  ASSERT_FALSE(nsn->complete);
   ASSERT_EQ(nsn->last_copied_object_number, 0);
 
   ASSERT_EQ(0, mirror_image_snapshot_set_copy_progress(&ioctx, oid, 2, true,
                                                        10));
   ASSERT_EQ(0, snapshot_get(&ioctx, oid, 2, &snap));
-  nsn = boost::get<cls::rbd::MirrorNonPrimarySnapshotNamespace>(
+  nsn = boost::get<cls::rbd::MirrorSnapshotNamespace>(
     &snap.snapshot_namespace);
   ASSERT_NE(nullptr, nsn);
-  ASSERT_TRUE(nsn->copied);
+  ASSERT_TRUE(nsn->complete);
   ASSERT_EQ(nsn->last_copied_object_number, 10);
 
   ASSERT_EQ(0, snapshot_remove(&ioctx, oid, 1));

diff --git a/src/test/librbd/mirror/snapshot/test_mock_Utils.cc b/src/test/librbd/mirror/snapshot/test_mock_Utils.cc
index a42f5ff30b3776b2a204ce6005df618f1e8c7fb4..206f5f69f827bf5481cb670c8beaaaf7abe42926 100644 (file)
--- a/src/test/librbd/mirror/snapshot/test_mock_Utils.cc
+++ b/src/test/librbd/mirror/snapshot/test_mock_Utils.cc
@@ -72,8 +72,9 @@ TEST_F(TestMockMirrorSnapshotUtils, CanCreatePrimarySnapshot) {
                                                 &rollback_snap_id));
   ASSERT_EQ(rollback_snap_id, CEPH_NOSNAP);
 
-  cls::rbd::MirrorNonPrimarySnapshotNamespace nns{"mirror_uuid", 123};
-  nns.copied = true;
+  cls::rbd::MirrorSnapshotNamespace nns{
+    cls::rbd::MIRROR_SNAPSHOT_STATE_NON_PRIMARY, {}, "mirror_uuid", 123};
+  nns.complete = true;
   auto copied_snap_id = snap_create(mock_image_ctx, nns, "NPS1");
 
   // without force, previous snapshot is non-primary
@@ -89,7 +90,7 @@ TEST_F(TestMockMirrorSnapshotUtils, CanCreatePrimarySnapshot) {
                                                 &rollback_snap_id));
   ASSERT_EQ(rollback_snap_id, CEPH_NOSNAP);
 
-  nns.copied = false;
+  nns.complete = false;
   snap_create(mock_image_ctx, nns, "NPS2");
 
   // previous non-primary snapshot is not copied yet
@@ -101,7 +102,7 @@ TEST_F(TestMockMirrorSnapshotUtils, CanCreatePrimarySnapshot) {
                                                 &rollback_snap_id));
   ASSERT_EQ(rollback_snap_id, copied_snap_id);
 
-  nns.primary_mirror_uuid.clear();
+  nns.state = cls::rbd::MIRROR_SNAPSHOT_STATE_NON_PRIMARY_DEMOTED;
   snap_create(mock_image_ctx, nns, "NPS3");
 
   // previous non-primary snapshot is orphan
@@ -139,13 +140,14 @@ TEST_F(TestMockMirrorSnapshotUtils, CanCreateNonPrimarySnapshot) {
   // no previous mirror snapshots found
   ASSERT_TRUE(util::can_create_non_primary_snapshot(&mock_image_ctx));
 
-  cls::rbd::MirrorNonPrimarySnapshotNamespace nns{"mirror_uuid", 123};
+  cls::rbd::MirrorSnapshotNamespace nns{
+    cls::rbd::MIRROR_SNAPSHOT_STATE_NON_PRIMARY, {}, "mirror_uuid", 123};
   snap_create(mock_image_ctx, nns, "NPS1");
 
   // previous non-primary snapshot is not copied yet
   ASSERT_FALSE(util::can_create_non_primary_snapshot(&mock_image_ctx));
 
-  nns.copied = true;
+  nns.complete = true;
   snap_create(mock_image_ctx, nns, "NPS2");
 
   // previous non-primary snapshot is copied