Partial changes for ImageWatcher

src/librbd/ImageState.h

@@ -73,6 +73,7 @@ class ImageState {
     ActionType action_type;
     uint64_t refresh_seq = 0;
     std::string snap_name;
+    cls::rbd::SnapshotNamespace snap_namespace;
     Context *on_ready = nullptr;
 
     Action(ActionType action_type) : action_type(action_type) {

src/librbd/ImageWatcher.cc

@@ -276,49 +276,53 @@ void ImageWatcher<I>::notify_snap_create(const std::string &snap_name,
 template <typename I>
 void ImageWatcher<I>::notify_snap_rename(const snapid_t &src_snap_id,
 				         const std::string &dst_snap_name,
-                                      Context *on_finish) {
+					 const cls::rbd::SnapshotNamespace &snap_namespace,
+					 Context *on_finish) {
   assert(m_image_ctx.owner_lock.is_locked());
   assert(m_image_ctx.exclusive_lock &&
          !m_image_ctx.exclusive_lock->is_lock_owner());
 
   bufferlist bl;
-  ::encode(NotifyMessage(SnapRenamePayload(src_snap_id, dst_snap_name)), bl);
+  ::encode(NotifyMessage(SnapRenamePayload(src_snap_id, dst_snap_name, snap_namespace)), bl);
   notify_lock_owner(std::move(bl), on_finish);
 }
 
 template <typename I>
 void ImageWatcher<I>::notify_snap_remove(const std::string &snap_name,
+					 const cls::rbd::SnapshotNamespace &snap_namespace,
                                          Context *on_finish) {
   assert(m_image_ctx.owner_lock.is_locked());
   assert(m_image_ctx.exclusive_lock &&
          !m_image_ctx.exclusive_lock->is_lock_owner());
 
   bufferlist bl;
-  ::encode(NotifyMessage(SnapRemovePayload(snap_name)), bl);
+  ::encode(NotifyMessage(SnapRemovePayload(snap_name, snap_namespace)), bl);
   notify_lock_owner(std::move(bl), on_finish);
 }
 
 template <typename I>
 void ImageWatcher<I>::notify_snap_protect(const std::string &snap_name,
+					  const cls::rbd::SnapshotNamespace &snap_namespace,
                                           Context *on_finish) {
   assert(m_image_ctx.owner_lock.is_locked());
   assert(m_image_ctx.exclusive_lock &&
          !m_image_ctx.exclusive_lock->is_lock_owner());
 
   bufferlist bl;
-  ::encode(NotifyMessage(SnapProtectPayload(snap_name)), bl);
+  ::encode(NotifyMessage(SnapProtectPayload(snap_name, snap_namespace)), bl);
   notify_lock_owner(std::move(bl), on_finish);
 }
 
 template <typename I>
 void ImageWatcher<I>::notify_snap_unprotect(const std::string &snap_name,
+					    const cls::rbd::SnapshotNamespace &snap_namespace,
                                             Context *on_finish) {
   assert(m_image_ctx.owner_lock.is_locked());
   assert(m_image_ctx.exclusive_lock &&
          !m_image_ctx.exclusive_lock->is_lock_owner());
 
   bufferlist bl;
-  ::encode(NotifyMessage(SnapUnprotectPayload(snap_name)), bl);
+  ::encode(NotifyMessage(SnapUnprotectPayload(snap_name, snap_namespace)), bl);
   notify_lock_owner(std::move(bl), on_finish);
 }
 
@@ -870,6 +874,7 @@ bool ImageWatcher<I>::handle_payload(const SnapRemovePayload &payload,
 			         << payload.snap_name << dendl;
 
       m_image_ctx.operations->execute_snap_remove(payload.snap_name,
+						  payload.snap_namespace,
                                                   new C_ResponseMessage(ack_ctx));
       return false;
     } else if (r < 0) {
@@ -890,6 +895,7 @@ bool ImageWatcher<I>::handle_payload(const SnapProtectPayload& payload,
                                  << payload.snap_name << dendl;
 
       m_image_ctx.operations->execute_snap_protect(payload.snap_name,
+						   payload.snap_namespace,
                                                    new C_ResponseMessage(ack_ctx));
       return false;
     } else if (r < 0) {
@@ -910,6 +916,7 @@ bool ImageWatcher<I>::handle_payload(const SnapUnprotectPayload& payload,
                                  << payload.snap_name << dendl;
 
       m_image_ctx.operations->execute_snap_unprotect(payload.snap_name,
+						     payload.snap_namespace,
                                                      new C_ResponseMessage(ack_ctx));
       return false;
     } else if (r < 0) {

src/librbd/ImageWatcher.h

@@ -42,10 +42,17 @@ class ImageWatcher {
 			  Context *on_finish);
   void notify_snap_rename(const snapid_t &src_snap_id,
                           const std::string &dst_snap_name,
+			  const cls::rbd::SnapshotNamespace &snap_namespace,
                           Context *on_finish);
-  void notify_snap_remove(const std::string &snap_name, Context *on_finish);
-  void notify_snap_protect(const std::string &snap_name, Context *on_finish);
-  void notify_snap_unprotect(const std::string &snap_name, Context *on_finish);
+  void notify_snap_remove(const std::string &snap_name,
+			  const cls::rbd::SnapshotNamespace &snap_namespace,
+			  Context *on_finish);
+  void notify_snap_protect(const std::string &snap_name, 
+			   const cls::rbd::SnapshotNamespace &snap_namespace,
+			   Context *on_finish);
+  void notify_snap_unprotect(const std::string &snap_name,
+			     const cls::rbd::SnapshotNamespace &snap_namespace,
+			     Context *on_finish);
   void notify_rebuild_object_map(uint64_t request_id,
                                  ProgressContext &prog_ctx, Context *on_finish);
   void notify_rename(const std::string &image_name, Context *on_finish);

src/librbd/Operations.cc

@@ -879,7 +879,7 @@ void Operations<I>::snap_remove(const char *snap_name,
       m_image_ctx, "snap_remove", true,
       boost::bind(&Operations<I>::execute_snap_remove, this, snap_name, snap_namespace, _1),
       boost::bind(&ImageWatcher<I>::notify_snap_remove, m_image_ctx.image_watcher,
-                  snap_name, _1),
+                  snap_name, snap_namespace, _1),
       {-ENOENT}, on_finish);
     req->send();
   } else {
@@ -967,7 +967,7 @@ int Operations<I>::snap_rename(const char *srcname, const char *dstname, const c
                                          this, snap_id, dstname, _1),
                              boost::bind(&ImageWatcher<I>::notify_snap_rename,
                                          m_image_ctx.image_watcher, snap_id,
-                                         dstname, _1));
+                                         dstname, snap_namespace, _1));
     if (r < 0 && r != -EEXIST) {
       return r;
     }
@@ -1061,7 +1061,7 @@ int Operations<I>::snap_protect(const char *snap_name, const cls::rbd::SnapshotN
                              boost::bind(&Operations<I>::execute_snap_protect,
                                          this, snap_name, snap_namespace, _1),
                              boost::bind(&ImageWatcher<I>::notify_snap_protect,
-                                         m_image_ctx.image_watcher, snap_name,
+                                         m_image_ctx.image_watcher, snap_name, snap_namespace,
                                          _1));
     if (r < 0 && r != -EBUSY) {
       return r;
@@ -1149,7 +1149,7 @@ int Operations<I>::snap_unprotect(const char *snap_name,
                              boost::bind(&Operations<I>::execute_snap_unprotect,
                                          this, snap_name, snap_namespace, _1),
                              boost::bind(&ImageWatcher<I>::notify_snap_unprotect,
-                                         m_image_ctx.image_watcher, snap_name,
+                                         m_image_ctx.image_watcher, snap_name, snap_namespace,
                                          _1));
     if (r < 0 && r != -EINVAL) {
       return r;

src/librbd/WatchNotifyTypes.cc

@@ -402,9 +402,9 @@ void NotifyMessage::generate_test_instances(std::list<NotifyMessage *> &o) {
   o.push_back(new NotifyMessage(ResizePayload(123, true, AsyncRequestId(ClientId(0, 1), 2))));
   o.push_back(new NotifyMessage(SnapCreatePayload("foo",
 						  cls::rbd::UserSnapshotNamespace())));
-  o.push_back(new NotifyMessage(SnapRemovePayload("foo")));
-  o.push_back(new NotifyMessage(SnapProtectPayload("foo")));
-  o.push_back(new NotifyMessage(SnapUnprotectPayload("foo")));
+  o.push_back(new NotifyMessage(SnapRemovePayload("foo", cls::rbd::UserSnapshotNamespace())));
+  o.push_back(new NotifyMessage(SnapProtectPayload("foo", cls::rbd::UserSnapshotNamespace())));
+  o.push_back(new NotifyMessage(SnapUnprotectPayload("foo", cls::rbd::UserSnapshotNamespace())));
   o.push_back(new NotifyMessage(RebuildObjectMapPayload(AsyncRequestId(ClientId(0, 1), 2))));
   o.push_back(new NotifyMessage(RenamePayload("foo")));
   o.push_back(new NotifyMessage(UpdateFeaturesPayload(1, true)));

src/librbd/WatchNotifyTypes.h

@@ -219,24 +219,23 @@ struct SnapPayloadBase {
   static const bool CHECK_FOR_REFRESH = true;
 
   std::string snap_name;
+  cls::rbd::SnapshotNamespace snap_namespace;
 
   void encode(bufferlist &bl) const;
   void decode(__u8 version, bufferlist::iterator &iter);
   void dump(Formatter *f) const;
 
 protected:
   SnapPayloadBase() {}
-  SnapPayloadBase(const std::string &name) : snap_name(name) {}
+  SnapPayloadBase(const std::string &name, const cls::rbd::SnapshotNamespace& _snap_namespace) : snap_name(name), snap_namespace(_snap_namespace) {}
 };
 
 struct SnapCreatePayload : public SnapPayloadBase {
   static const NotifyOp NOTIFY_OP = NOTIFY_OP_SNAP_CREATE;
 
   SnapCreatePayload() {}
   SnapCreatePayload(const std::string &name,
-		    const cls::rbd::SnapshotNamespace &_snap_namespace) : SnapPayloadBase(name), snap_namespace(_snap_namespace) {}
-
-  cls::rbd::SnapshotNamespace snap_namespace;
+		    const cls::rbd::SnapshotNamespace &_snap_namespace) : SnapPayloadBase(name, snap_namespace) {}
 
   void encode(bufferlist &bl) const;
   void decode(__u8 version, bufferlist::iterator &iter);
@@ -247,8 +246,8 @@ struct SnapRenamePayload : public SnapPayloadBase {
   static const NotifyOp NOTIFY_OP = NOTIFY_OP_SNAP_RENAME;
 
   SnapRenamePayload() {}
-  SnapRenamePayload(const uint64_t &src_snap_id, const std::string &dst_name)
-    : SnapPayloadBase(dst_name), snap_id(src_snap_id) {}
+  SnapRenamePayload(const uint64_t &src_snap_id, const std::string &dst_name, const cls::rbd::SnapshotNamespace& snap_namespace)
+    : SnapPayloadBase(dst_name, snap_namespace), snap_id(src_snap_id) {}
 
   uint64_t snap_id;
 
@@ -261,21 +260,21 @@ struct SnapRemovePayload : public SnapPayloadBase {
   static const NotifyOp NOTIFY_OP = NOTIFY_OP_SNAP_REMOVE;
 
   SnapRemovePayload() {}
-  SnapRemovePayload(const std::string &name) : SnapPayloadBase(name) {}
+  SnapRemovePayload(const std::string &name, const cls::rbd::SnapshotNamespace& snap_namespace) : SnapPayloadBase(name, snap_namespace) {}
 };
 
 struct SnapProtectPayload : public SnapPayloadBase {
   static const NotifyOp NOTIFY_OP = NOTIFY_OP_SNAP_PROTECT;
 
   SnapProtectPayload() {}
-  SnapProtectPayload(const std::string &name) : SnapPayloadBase(name) {}
+  SnapProtectPayload(const std::string &name, const cls::rbd::SnapshotNamespace& snap_namespace) : SnapPayloadBase(name, snap_namespace) {}
 };
 
 struct SnapUnprotectPayload : public SnapPayloadBase {
   static const NotifyOp NOTIFY_OP = NOTIFY_OP_SNAP_UNPROTECT;
 
   SnapUnprotectPayload() {}
-  SnapUnprotectPayload(const std::string &name) : SnapPayloadBase(name) {}
+  SnapUnprotectPayload(const std::string &name, const cls::rbd::SnapshotNamespace& snap_namespace) : SnapPayloadBase(name, snap_namespace) {}
 };
 
 struct RebuildObjectMapPayload : public AsyncRequestPayloadBase {

src/librbd/image/RefreshRequest.cc

@@ -1008,7 +1008,7 @@ void RefreshRequest<I>::apply() {
     m_image_ctx.snapc = m_snapc;
 
     if (m_image_ctx.snap_id != CEPH_NOSNAP &&
-        m_image_ctx.get_snap_id(m_image_ctx.snap_name) != m_image_ctx.snap_id) {
+        m_image_ctx.get_snap_id(m_image_ctx.snap_namespace, m_image_ctx.snap_name) != m_image_ctx.snap_id) {
       lderr(cct) << "tried to read from a snapshot that no longer exists: "
                  << m_image_ctx.snap_name << dendl;
       m_image_ctx.snap_exists = false;

src/librbd/image/SetSnapRequest.cc

@@ -22,8 +22,9 @@ using util::create_context_callback;
 
 template <typename I>
 SetSnapRequest<I>::SetSnapRequest(I &image_ctx, const std::string &snap_name,
+				  const cls::rbd::SnapshotNamespace& snap_namespace, 
                                   Context *on_finish)
-  : m_image_ctx(image_ctx), m_snap_name(snap_name), m_on_finish(on_finish),
+  : m_image_ctx(image_ctx), m_snap_name(snap_name), m_snap_namespace(snap_namespace), m_on_finish(on_finish),
     m_snap_id(CEPH_NOSNAP), m_exclusive_lock(nullptr), m_object_map(nullptr),
     m_refresh_parent(nullptr), m_writes_blocked(false) {
 }
@@ -121,7 +122,7 @@ Context *SetSnapRequest<I>::handle_block_writes(int *result) {
 
   {
     RWLock::RLocker snap_locker(m_image_ctx.snap_lock);
-    m_snap_id = m_image_ctx.get_snap_id(m_snap_name);
+    m_snap_id = m_image_ctx.get_snap_id(m_snap_namespace, m_snap_name);
     if (m_snap_id == CEPH_NOSNAP) {
       ldout(cct, 5) << "failed to locate snapshot '" << m_snap_name << "'"
                     << dendl;
@@ -328,7 +329,7 @@ int SetSnapRequest<I>::apply() {
   RWLock::WLocker parent_locker(m_image_ctx.parent_lock);
   if (m_snap_id != CEPH_NOSNAP) {
     assert(m_image_ctx.exclusive_lock == nullptr);
-    int r = m_image_ctx.snap_set(m_snap_name);
+    int r = m_image_ctx.snap_set(m_snap_namespace, m_snap_name);
     if (r < 0) {
       return r;
     }

src/librbd/image/SetSnapRequest.h

@@ -4,6 +4,7 @@
 #ifndef CEPH_LIBRBD_IMAGE_SNAP_SET_REQUEST_H
 #define CEPH_LIBRBD_IMAGE_SNAP_SET_REQUEST_H
 
+#include "cls/rbd/cls_rbd_client.h"
 #include <string>
 
 class Context;
@@ -23,8 +24,9 @@ class SetSnapRequest {
 public:
   static SetSnapRequest *create(ImageCtxT &image_ctx,
                                 const std::string &snap_name,
+				const cls::rbd::SnapshotNamespace& snap_namespace, 
                                 Context *on_finish) {
-    return new SetSnapRequest(image_ctx, snap_name, on_finish);
+    return new SetSnapRequest(image_ctx, snap_name, snap_namespace, on_finish);
   }
 
   ~SetSnapRequest();
@@ -76,10 +78,12 @@ class SetSnapRequest {
    */
 
   SetSnapRequest(ImageCtxT &image_ctx, const std::string &snap_name,
+		 const cls::rbd::SnapshotNamespace& snap_namespace, 
                 Context *on_finish);
 
   ImageCtxT &m_image_ctx;
   std::string m_snap_name;
+  cls::rbd::SnapshotNamespace m_snap_namespace;
   Context *m_on_finish;
 
   uint64_t m_snap_id;