librbd: add new RBD_FLAG_FAST_DIFF_INVALID flag

Since fast diff can be enabled/disabled independently from the object
map, it's important to track when the fast diff portion of the object
map is invalid.

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

diff --git a/src/include/rbd/librbd.h b/src/include/rbd/librbd.h
index 7157eaf766d181ded688e70fc909c15dc812d544..690dbbd507442c229487604c2e4d4d58531e6737 100644 (file)
--- a/src/include/rbd/librbd.h
+++ b/src/include/rbd/librbd.h
@@ -48,6 +48,7 @@ extern "C" {
 #endif
 
 #define RBD_FLAG_OBJECT_MAP_INVALID   (1<<0)
+#define RBD_FLAG_FAST_DIFF_INVALID    (1<<1)
 
 typedef void *rbd_snap_t;
 typedef void *rbd_image_t;

diff --git a/src/librbd/ObjectMap.cc b/src/librbd/ObjectMap.cc
index a13b02d2e367ece684b03fe4cacbfc98d9772106..3f0bb453e1dee55dbc09f701cc961749ce294053 100644 (file)
--- a/src/librbd/ObjectMap.cc
+++ b/src/librbd/ObjectMap.cc
@@ -489,9 +489,14 @@ void ObjectMap::invalidate(uint64_t snap_id) {
     return;
   }
 
+  flags = RBD_FLAG_OBJECT_MAP_INVALID;
+  if ((m_image_ctx.features & RBD_FEATURE_FAST_DIFF) != 0) {
+    flags |= RBD_FLAG_FAST_DIFF_INVALID;
+  }
+
   CephContext *cct = m_image_ctx.cct;
   lderr(cct) << &m_image_ctx << " invalidating object map" << dendl;
-  int r = m_image_ctx.update_flags(snap_id, RBD_FLAG_OBJECT_MAP_INVALID, true);
+  int r = m_image_ctx.update_flags(snap_id, flags, true);
   if (r < 0) {
     lderr(cct) << "failed to invalidate in-memory object map: "
                << cpp_strerror(r) << dendl;
@@ -499,8 +504,7 @@ void ObjectMap::invalidate(uint64_t snap_id) {
   }
 
   librados::ObjectWriteOperation op;
-  cls_client::set_flags(&op, snap_id, m_image_ctx.flags,
-                        RBD_FLAG_OBJECT_MAP_INVALID);
+  cls_client::set_flags(&op, snap_id, flags, flags);
 
   r = m_image_ctx.md_ctx.operate(m_image_ctx.header_oid, &op);
   if (r < 0) {
@@ -567,13 +571,17 @@ bool ObjectMap::Request::invalidate() {
   // requests shouldn't be running while using snapshots
   assert(m_image_ctx.snap_id == CEPH_NOSNAP);
 
+  uint64_t flags = RBD_FLAG_OBJECT_MAP_INVALID;
+  if ((m_image_ctx.features & RBD_FEATURE_FAST_DIFF) != 0) {
+    flags |= RBD_FLAG_FAST_DIFF_INVALID;
+  }
+
   lderr(cct) << &m_image_ctx << " invalidating object map" << dendl;
   m_state = STATE_INVALIDATE;
-  m_image_ctx.flags |= RBD_FLAG_OBJECT_MAP_INVALID;
+  m_image_ctx.flags |= flags;
 
   librados::ObjectWriteOperation op;
-  cls_client::set_flags(&op, CEPH_NOSNAP, m_image_ctx.flags,
-                        RBD_FLAG_OBJECT_MAP_INVALID);
+  cls_client::set_flags(&op, CEPH_NOSNAP, flags, flags);
 
   librados::AioCompletion *rados_completion = create_callback_completion();
   int r = m_image_ctx.md_ctx.aio_operate(m_image_ctx.header_oid,

diff --git a/src/librbd/RebuildObjectMapRequest.cc b/src/librbd/RebuildObjectMapRequest.cc
index 052600aa43bac94c1ed0bca7700a066980d2348a..b2520d0615ad091a998e2fe888119a7e45482bdc 100644 (file)
--- a/src/librbd/RebuildObjectMapRequest.cc
+++ b/src/librbd/RebuildObjectMapRequest.cc
@@ -312,20 +312,20 @@ bool RebuildObjectMapRequest::send_update_header() {
     } else {
       ldout(cct, 5) << this << " send_update_header" << dendl;
 
+      uint64_t flags = RBD_FLAG_OBJECT_MAP_INVALID | RBD_FLAG_FAST_DIFF_INVALID;
+
       librados::ObjectWriteOperation op;
       if (m_image_ctx.image_watcher->is_lock_supported()) {
         m_image_ctx.image_watcher->assert_header_locked(&op);
       }
-      cls_client::set_flags(&op, m_image_ctx.snap_id, 0,
-                            RBD_FLAG_OBJECT_MAP_INVALID);
+      cls_client::set_flags(&op, m_image_ctx.snap_id, 0, flags);
 
       int r = m_image_ctx.md_ctx.aio_operate(m_image_ctx.header_oid,
                                              create_callback_completion(), &op);
       assert(r == 0);
 
       RWLock::WLocker snap_locker(m_image_ctx.snap_lock);
-      m_image_ctx.update_flags(m_image_ctx.snap_id, RBD_FLAG_OBJECT_MAP_INVALID,
-                               false);
+      m_image_ctx.update_flags(m_image_ctx.snap_id, flags, false);
       return false;
     }
   }

diff --git a/src/librbd/internal.cc b/src/librbd/internal.cc
index 532f10219b7f21281d485480edbed79e1269f8d2..f35ef2c13d0a60906af1cd47a42b2593f1520f0f 100644 (file)
--- a/src/librbd/internal.cc
+++ b/src/librbd/internal.cc
@@ -104,7 +104,7 @@ int diff_object_map(ImageCtx* ictx, uint64_t from_snap_id, uint64_t to_snap_id,
       lderr(cct) << "diff_object_map: failed to retrieve image flags" << dendl;
       return r;
     }
-    if ((flags & RBD_FLAG_OBJECT_MAP_INVALID) != 0) {
+    if ((flags & RBD_FLAG_FAST_DIFF_INVALID) != 0) {
       ldout(cct, 1) << "diff_object_map: cannot perform fast diff on invalid "
                     << "object map" << dendl;
       return -EINVAL;
@@ -2303,6 +2303,9 @@ reprotect_and_return_err:
                                   << "disabling object map optimizations"
                                   << dendl;
              ictx->flags = RBD_FLAG_OBJECT_MAP_INVALID;
+              if ((ictx->features & RBD_FEATURE_FAST_DIFF) != 0) {
+                ictx->flags |= RBD_FLAG_FAST_DIFF_INVALID;
+              }
 
              vector<uint64_t> default_flags(new_snapc.snaps.size(), ictx->flags);
              snap_flags.swap(default_flags);

diff --git a/src/rbd.cc b/src/rbd.cc
index d4f1eb0d287b2e9c34ee210f4d3fbc6ad8949fd2..e0703b509102abed4ae68a4c04cba4becf1b2442 100644 (file)
--- a/src/rbd.cc
+++ b/src/rbd.cc
@@ -249,7 +249,8 @@ static void format_features(Formatter *f, uint64_t features)
 static void format_flags(Formatter *f, uint64_t flags)
 {
   std::map<uint64_t, std::string> mapping = boost::assign::map_list_of(
-    RBD_FLAG_OBJECT_MAP_INVALID, "object map invalid");
+    RBD_FLAG_OBJECT_MAP_INVALID, "object map invalid")(
+    RBD_FLAG_FAST_DIFF_INVALID, "fast diff invalid");
   format_bitmask(f, "flag", mapping, flags);
 }