From: Jason Dillaman <dillaman@redhat.com>
Date: Tue, 8 Dec 2015 19:37:09 +0000 (-0500)
Subject: librbd: object map lifespan now controlled by state machines
X-Git-Tag: v10.0.2~35^2~13
X-Git-Url: http://git-server-git.apps.pok.os.sepia.ceph.com/?a=commitdiff_plain;h=167333235343ebd11e471427af7a66c88246e93b;p=ceph.git

librbd: object map lifespan now controlled by state machines

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

diff --git a/src/librbd/AioObjectRequest.cc b/src/librbd/AioObjectRequest.cc
index d0805fbfdb52..67f9fe3c349d 100644
--- a/src/librbd/AioObjectRequest.cc
+++ b/src/librbd/AioObjectRequest.cc
@@ -7,15 +7,15 @@
 #include "common/Mutex.h"
 #include "common/RWLock.h"
 
+#include "librbd/AioObjectRequest.h"
 #include "librbd/AioCompletion.h"
 #include "librbd/AioImageRequest.h"
+#include "librbd/CopyupRequest.h"
 #include "librbd/ExclusiveLock.h"
 #include "librbd/ImageCtx.h"
 #include "librbd/ImageWatcher.h"
 #include "librbd/internal.h"
-
-#include "librbd/AioObjectRequest.h"
-#include "librbd/CopyupRequest.h"
+#include "librbd/ObjectMap.h"
 #include "librbd/Utils.h"
 
 #include <boost/bind.hpp>
@@ -206,7 +206,13 @@ namespace librbd {
                            << m_object_off << "~" << m_object_len << dendl;
 
     // send read request to parent if the object doesn't exist locally
-    if (!m_ictx->object_map.object_may_exist(m_object_no)) {
+    bool non_existent = false;
+    {
+      RWLock::RLocker snap_locker(m_ictx->snap_lock);
+      non_existent = (m_ictx->object_map != nullptr &&
+                      !m_ictx->object_map->object_may_exist(m_object_no));
+    }
+    if (non_existent) {
       complete(-ENOENT);
       return;
     }
@@ -380,16 +386,18 @@ namespace librbd {
   void AbstractAioObjectWrite::send_pre() {
     assert(m_ictx->owner_lock.is_locked());
 
-    m_object_exist = m_ictx->object_map.object_may_exist(m_object_no);
     bool write = false;
     {
       RWLock::RLocker snap_lock(m_ictx->snap_lock);
-      if (!m_ictx->object_map.enabled()) {
+      if (m_ictx->object_map == nullptr) {
+        m_object_exist = true;
         write = true;
       } else {
         // should have been flushed prior to releasing lock
         assert(m_ictx->exclusive_lock->is_lock_owner());
 
+        m_object_exist = m_ictx->object_map->object_may_exist(m_object_no);
+
         ldout(m_ictx->cct, 20) << "send_pre " << this << " " << m_oid << " "
           		       << m_object_off << "~" << m_object_len << dendl;
         m_state = LIBRBD_AIO_WRITE_PRE;
@@ -399,10 +407,10 @@ namespace librbd {
         pre_object_map_update(&new_state);
 
         RWLock::WLocker object_map_locker(m_ictx->object_map_lock);
-        if (m_ictx->object_map[m_object_no] != new_state) {
+        if ((*m_ictx->object_map)[m_object_no] != new_state) {
           Context *ctx = util::create_context_callback<AioObjectRequest>(this);
-          bool updated = m_ictx->object_map.aio_update(m_object_no, new_state,
-                                                       current_state, ctx);
+          bool updated = m_ictx->object_map->aio_update(m_object_no, new_state,
+                                                        current_state, ctx);
           assert(updated);
         } else {
           write = true;
@@ -420,7 +428,7 @@ namespace librbd {
   bool AbstractAioObjectWrite::send_post() {
     RWLock::RLocker owner_locker(m_ictx->owner_lock);
     RWLock::RLocker snap_locker(m_ictx->snap_lock);
-    if (!m_ictx->object_map.enabled() || !post_object_map_update()) {
+    if (m_ictx->object_map == nullptr || !post_object_map_update()) {
       return true;
     }
 
@@ -432,16 +440,16 @@ namespace librbd {
     m_state = LIBRBD_AIO_WRITE_POST;
 
     RWLock::WLocker object_map_locker(m_ictx->object_map_lock);
-    uint8_t current_state = m_ictx->object_map[m_object_no];
+    uint8_t current_state = (*m_ictx->object_map)[m_object_no];
     if (current_state != OBJECT_PENDING ||
         current_state == OBJECT_NONEXISTENT) {
       return true;
     }
 
     Context *ctx = util::create_context_callback<AioObjectRequest>(this);
-    bool updated = m_ictx->object_map.aio_update(m_object_no,
-                                                 OBJECT_NONEXISTENT,
-				                 OBJECT_PENDING, ctx);
+    bool updated = m_ictx->object_map->aio_update(m_object_no,
+                                                  OBJECT_NONEXISTENT,
+				                  OBJECT_PENDING, ctx);
     assert(updated);
     return false;
   }
@@ -519,8 +527,13 @@ namespace librbd {
   }
 
   void AioObjectWrite::add_write_ops(librados::ObjectWriteOperation *wr) {
-    if (m_ictx->enable_alloc_hint && !m_ictx->object_map.object_may_exist(m_object_no))
+    RWLock::RLocker snap_locker(m_ictx->snap_lock);
+    if (m_ictx->enable_alloc_hint &&
+        (m_ictx->object_map == nullptr ||
+         !m_ictx->object_map->object_may_exist(m_object_no))) {
       wr->set_alloc_hint(m_ictx->get_object_size(), m_ictx->get_object_size());
+    }
+
     if (m_object_off == 0 && m_object_len == m_ictx->get_object_size()) {
       wr->write_full(m_write_data);
     } else {
diff --git a/src/librbd/CopyupRequest.cc b/src/librbd/CopyupRequest.cc
index 736b1d51c0a3..9adf3383ef0c 100644
--- a/src/librbd/CopyupRequest.cc
+++ b/src/librbd/CopyupRequest.cc
@@ -47,9 +47,10 @@ public:
       RWLock::RLocker snap_locker(m_image_ctx.snap_lock);
       RWLock::WLocker object_map_locker(m_image_ctx.object_map_lock);
       assert(m_image_ctx.exclusive_lock->is_lock_owner());
-      bool sent = m_image_ctx.object_map.aio_update(m_object_no, OBJECT_EXISTS,
-                                                    boost::optional<uint8_t>(),
-                                                    this);
+      assert(m_image_ctx.object_map != nullptr);
+      bool sent = m_image_ctx.object_map->aio_update(m_object_no, OBJECT_EXISTS,
+                                                     boost::optional<uint8_t>(),
+                                                     this);
       return (sent ? 0 : 1);
     }
 
@@ -61,8 +62,12 @@ public:
 
     RWLock::RLocker snap_locker(m_image_ctx.snap_lock);
     RWLock::RLocker object_map_locker(m_image_ctx.object_map_lock);
-    m_image_ctx.object_map.aio_update(snap_id, m_object_no, m_object_no + 1,
-                                      state, boost::optional<uint8_t>(), this);
+    if (m_image_ctx.object_map == nullptr) {
+      return 1;
+    }
+
+    m_image_ctx.object_map->aio_update(snap_id, m_object_no, m_object_no + 1,
+                                       state, boost::optional<uint8_t>(), this);
     return 0;
   }
 
@@ -270,7 +275,7 @@ private:
     {
       RWLock::RLocker owner_locker(m_ictx->owner_lock);
       RWLock::RLocker snap_locker(m_ictx->snap_lock);
-      if (m_ictx->object_map.enabled()) {
+      if (m_ictx->object_map != nullptr) {
         bool copy_on_read = m_pending_requests.empty();
         if (!m_ictx->exclusive_lock->is_lock_owner()) {
           ldout(m_ictx->cct, 20) << "exclusive lock not held for copyup request"
@@ -280,7 +285,8 @@ private:
         }
 
         RWLock::WLocker object_map_locker(m_ictx->object_map_lock);
-        if (copy_on_read && m_ictx->object_map[m_object_no] != OBJECT_EXISTS) {
+        if (copy_on_read &&
+            (*m_ictx->object_map)[m_object_no] != OBJECT_EXISTS) {
           // CoW already updates the HEAD object map
           m_snap_ids.push_back(CEPH_NOSNAP);
         }
diff --git a/src/librbd/DiffIterate.cc b/src/librbd/DiffIterate.cc
index 8982764ffc37..9e4bc17fe08a 100644
--- a/src/librbd/DiffIterate.cc
+++ b/src/librbd/DiffIterate.cc
@@ -4,6 +4,7 @@
 #include "librbd/DiffIterate.h"
 #include "librbd/ImageCtx.h"
 #include "librbd/internal.h"
+#include "librbd/ObjectMap.h"
 #include "librbd/Utils.h"
 #include "include/rados/librados.hpp"
 #include "include/interval_set.h"
diff --git a/src/librbd/ImageCtx.cc b/src/librbd/ImageCtx.cc
index 959f8977609c..06afdcf68bbc 100644
--- a/src/librbd/ImageCtx.cc
+++ b/src/librbd/ImageCtx.cc
@@ -165,7 +165,7 @@ struct C_InvalidateCache : public Context {
       readahead(),
       total_bytes_read(0), copyup_finisher(NULL),
       exclusive_lock(nullptr),
-      object_map(*this), object_map_ptr(nullptr), aio_work_queue(NULL), op_work_queue(NULL),
+      object_map(nullptr), aio_work_queue(NULL), op_work_queue(NULL),
       refresh_in_progress(false), asok_hook(new LibrbdAdminSocketHook(this))
   {
     md_ctx.dup(p);
@@ -483,7 +483,6 @@ struct C_InvalidateCache : public Context {
       snap_name = in_snap_name;
       snap_exists = true;
       data_ctx.snap_set_read(snap_id);
-      object_map.refresh(in_snap_id);
       return 0;
     }
     return -ENOENT;
@@ -496,7 +495,6 @@ struct C_InvalidateCache : public Context {
     snap_name = "";
     snap_exists = true;
     data_ctx.snap_set_read(snap_id);
-    object_map.refresh(CEPH_NOSNAP);
   }
 
   snap_t ImageCtx::get_snap_id(string in_snap_name) const
diff --git a/src/librbd/ImageCtx.h b/src/librbd/ImageCtx.h
index dad549148147..a7534ebc768c 100644
--- a/src/librbd/ImageCtx.h
+++ b/src/librbd/ImageCtx.h
@@ -29,7 +29,6 @@
 #include "cls/rbd/cls_rbd_client.h"
 #include "librbd/AsyncRequest.h"
 #include "librbd/LibrbdWriteback.h"
-#include "librbd/ObjectMap.h"
 #include "librbd/SnapInfo.h"
 #include "librbd/parent_types.h"
 
@@ -49,6 +48,7 @@ namespace librbd {
   class ImageWatcher;
   class Journal;
   class LibrbdAdminSocketHook;
+  class ObjectMap;
 
   namespace operation {
   template <typename> class ResizeRequest;
@@ -99,7 +99,8 @@ namespace librbd {
                    // lock_tag
                    // lockers
     Mutex cache_lock; // used as client_lock for the ObjectCacher
-    RWLock snap_lock; // protects snapshot-related member variables, features, and flags
+    RWLock snap_lock; // protects snapshot-related member variables,
+                      // features (and associated helper classes), and flags
     RWLock parent_lock; // protects parent_md and parent
     Mutex refresh_lock; // protects refresh_seq and last_refresh
     RWLock object_map_lock; // protects object map updates and object_map itself
@@ -140,8 +141,7 @@ namespace librbd {
 
     ExclusiveLock<ImageCtx> *exclusive_lock;
 
-    ObjectMap object_map;         // TODO
-    ObjectMap *object_map_ptr;
+    ObjectMap *object_map;
 
     atomic_t async_request_seq;
 
diff --git a/src/librbd/LibrbdWriteback.cc b/src/librbd/LibrbdWriteback.cc
index 1147c36c1cc6..85fc513f9785 100644
--- a/src/librbd/LibrbdWriteback.cc
+++ b/src/librbd/LibrbdWriteback.cc
@@ -189,7 +189,9 @@ namespace librbd {
                                      &m_lock);
 
     {
-      if (!m_ictx->object_map.object_may_exist(object_no)) {
+      RWLock::RLocker snap_locker(m_ictx->snap_lock);
+      if (m_ictx->object_map != nullptr &&
+          !m_ictx->object_map->object_may_exist(object_no)) {
 	m_finisher->queue(req, -ENOENT);
 	return;
       }
diff --git a/src/librbd/ObjectMap.cc b/src/librbd/ObjectMap.cc
index 9499dc10c64a..c023398158b9 100644
--- a/src/librbd/ObjectMap.cc
+++ b/src/librbd/ObjectMap.cc
@@ -45,7 +45,7 @@ struct C_ApplyRefresh : public Context {
 } // anonymous namespace
 
 ObjectMap::ObjectMap(ImageCtx &image_ctx)
-  : m_image_ctx(image_ctx), m_snap_id(CEPH_NOSNAP), m_enabled(false)
+  : m_image_ctx(image_ctx), m_snap_id(CEPH_NOSNAP)
 {
 }
 
@@ -79,30 +79,12 @@ uint8_t ObjectMap::operator[](uint64_t object_no) const
   return m_object_map[object_no];
 }
 
-bool ObjectMap::enabled() const
-{
-  RWLock::RLocker l(m_image_ctx.object_map_lock);
-  return m_enabled;
-}
-
-bool ObjectMap::enabled(const RWLock &object_map_lock) const {
-  assert(m_image_ctx.object_map_lock.is_locked());
-  return m_enabled;
-}
-
 int ObjectMap::lock()
 {
   if (!m_image_ctx.test_features(RBD_FEATURE_OBJECT_MAP)) {
     return 0;
   }
 
-  {
-    RWLock::RLocker l(m_image_ctx.object_map_lock);
-    if (!m_enabled) {
-      return 0;
-    }
-  }
-
   bool broke_lock = false;
   CephContext *cct = m_image_ctx.cct;
   std::string oid(object_map_name(m_image_ctx.id, CEPH_NOSNAP));
@@ -196,9 +178,6 @@ bool ObjectMap::object_may_exist(uint64_t object_no) const
   }
 
   RWLock::RLocker l(m_image_ctx.object_map_lock);
-  if (!m_enabled) {
-    return true;
-  }
   uint8_t state = (*this)[object_no];
   bool exists = (state != OBJECT_NONEXISTENT);
   ldout(m_image_ctx.cct, 20) << &m_image_ctx << " object_may_exist: "
@@ -213,14 +192,6 @@ void ObjectMap::refresh(uint64_t snap_id)
   RWLock::WLocker l(m_image_ctx.object_map_lock);
   m_snap_id = snap_id;
 
-  if ((m_image_ctx.features & RBD_FEATURE_OBJECT_MAP) == 0 ||
-      (m_image_ctx.snap_id == snap_id && !m_image_ctx.snap_exists)) {
-    m_object_map.clear();
-    m_enabled = false;
-    return;
-  }
-  m_enabled = true;
-
   CephContext *cct = m_image_ctx.cct;
   std::string oid(object_map_name(m_image_ctx.id, snap_id));
   ldout(cct, 10) << &m_image_ctx << " refreshing object map: "
@@ -297,7 +268,6 @@ Context* ObjectMap::refresh(uint64_t snap_id, Context *on_finish) {
 void ObjectMap::rollback(uint64_t snap_id, Context *on_finish) {
   assert(m_image_ctx.snap_lock.is_locked());
   assert(m_image_ctx.object_map_lock.is_wlocked());
-  assert(m_enabled);
 
   object_map::SnapshotRollbackRequest *req =
     new object_map::SnapshotRollbackRequest(m_image_ctx, snap_id, on_finish);
diff --git a/src/librbd/ObjectMap.h b/src/librbd/ObjectMap.h
index 219d352d035a..39de022c02f5 100644
--- a/src/librbd/ObjectMap.h
+++ b/src/librbd/ObjectMap.h
@@ -60,14 +60,10 @@ public:
   void snapshot_add(uint64_t snap_id, Context *on_finish);
   void snapshot_remove(uint64_t snap_id, Context *on_finish);
 
-  bool enabled() const;
-  bool enabled(const RWLock &object_map_lock) const;
-
 private:
   ImageCtx &m_image_ctx;
   ceph::BitVector<2> m_object_map;
   uint64_t m_snap_id;
-  bool m_enabled;
 
   void invalidate(uint64_t snap_id, bool force);
 };
diff --git a/src/librbd/exclusive_lock/ReleaseRequest.cc b/src/librbd/exclusive_lock/ReleaseRequest.cc
index af0cb5dddd01..fbf325490fed 100644
--- a/src/librbd/exclusive_lock/ReleaseRequest.cc
+++ b/src/librbd/exclusive_lock/ReleaseRequest.cc
@@ -108,7 +108,7 @@ template <typename I>
 void ReleaseRequest<I>::send_unlock_object_map() {
   {
     RWLock::WLocker snap_locker(m_image_ctx.snap_lock);
-    std::swap(m_object_map, m_image_ctx.object_map_ptr);
+    std::swap(m_object_map, m_image_ctx.object_map);
   }
 
   if (m_object_map == nullptr) {
diff --git a/src/librbd/exclusive_lock/ReleaseRequest.h b/src/librbd/exclusive_lock/ReleaseRequest.h
index 2523181927d0..a7946f52a7a5 100644
--- a/src/librbd/exclusive_lock/ReleaseRequest.h
+++ b/src/librbd/exclusive_lock/ReleaseRequest.h
@@ -56,7 +56,7 @@ private:
   std::string m_cookie;
   Context *m_on_finish;
 
-  decltype(m_image_ctx.object_map_ptr) m_object_map;
+  decltype(m_image_ctx.object_map) m_object_map;
   decltype(m_image_ctx.journal) m_journal;
 
   void send_cancel_op_requests();
diff --git a/src/librbd/image/SetSnapRequest.cc b/src/librbd/image/SetSnapRequest.cc
index d88545e854fe..89b56739a358 100644
--- a/src/librbd/image/SetSnapRequest.cc
+++ b/src/librbd/image/SetSnapRequest.cc
@@ -326,7 +326,7 @@ int SetSnapRequest<I>::apply() {
   }
 
   std::swap(m_exclusive_lock, m_image_ctx.exclusive_lock);
-  std::swap(m_object_map, m_image_ctx.object_map_ptr);
+  std::swap(m_object_map, m_image_ctx.object_map);
   return 0;
 }
 
diff --git a/src/librbd/internal.cc b/src/librbd/internal.cc
index bfe917503adf..03a941b7c593 100644
--- a/src/librbd/internal.cc
+++ b/src/librbd/internal.cc
@@ -2605,7 +2605,8 @@ int validate_pool(IoCtx &io_ctx, CephContext *cct) {
 	ictx->snap_exists = false;
       }
 
-      ictx->object_map.refresh(ictx->snap_id);
+      // TODO handle by new async refresh state machine
+      //ictx->object_map.refresh(ictx->snap_id);
 
       ictx->data_ctx.selfmanaged_snap_set_write_ctx(ictx->snapc.seq, ictx->snaps);
 
diff --git a/src/librbd/operation/RebuildObjectMapRequest.cc b/src/librbd/operation/RebuildObjectMapRequest.cc
index d043b88003fa..ce7f911b99ea 100644
--- a/src/librbd/operation/RebuildObjectMapRequest.cc
+++ b/src/librbd/operation/RebuildObjectMapRequest.cc
@@ -145,8 +145,11 @@ private:
     assert(image_ctx.exclusive_lock == nullptr ||
            image_ctx.exclusive_lock->is_lock_owner());
 
+    RWLock::RLocker snap_locker(image_ctx.snap_lock);
+    assert(image_ctx.object_map != nullptr);
+
     RWLock::WLocker l(image_ctx.object_map_lock);
-    uint8_t state = image_ctx.object_map[m_object_no];
+    uint8_t state = (*image_ctx.object_map)[m_object_no];
     if (state == OBJECT_EXISTS && new_state == OBJECT_NONEXISTENT &&
         m_snap_id == CEPH_NOSNAP) {
       // might be writing object to OSD concurrently
@@ -157,7 +160,7 @@ private:
       ldout(cct, 15) << m_oid << " C_VerifyObject::update_object_map "
                      << static_cast<uint32_t>(state) << "->"
                      << static_cast<uint32_t>(new_state) << dendl;
-      image_ctx.object_map[m_object_no] = new_state;
+      (*image_ctx.object_map)[m_object_no] = new_state;
     }
     return true;
   }
@@ -234,15 +237,14 @@ void RebuildObjectMapRequest<I>::send_resize_object_map() {
   assert(m_image_ctx.owner_lock.is_locked());
   CephContext *cct = m_image_ctx.cct;
 
-  uint64_t num_objects;
-  uint64_t size;
-  {
-    RWLock::RLocker l(m_image_ctx.snap_lock);
-    size = get_image_size();
-    num_objects = Striper::get_num_objects(m_image_ctx.layout, size);
-  }
+  m_image_ctx.snap_lock.get_read();
+  assert(m_image_ctx.object_map != nullptr);
+
+  uint64_t size = get_image_size();
+  uint64_t num_objects = Striper::get_num_objects(m_image_ctx.layout, size);
 
-  if (m_image_ctx.object_map.size() == num_objects) {
+  if (m_image_ctx.object_map->size() == num_objects) {
+    m_image_ctx.snap_lock.put_read();
     send_verify_objects();
     return;
   }
@@ -253,8 +255,10 @@ void RebuildObjectMapRequest<I>::send_resize_object_map() {
   // should have been canceled prior to releasing lock
   assert(m_image_ctx.exclusive_lock == nullptr ||
          m_image_ctx.exclusive_lock->is_lock_owner());
-  m_image_ctx.object_map.aio_resize(size, OBJECT_NONEXISTENT,
-                                    this->create_callback_context());
+
+  m_image_ctx.object_map->aio_resize(size, OBJECT_NONEXISTENT,
+                                     this->create_callback_context());
+  m_image_ctx.snap_lock.put_read();
 }
 
 template <typename I>
@@ -273,9 +277,11 @@ void RebuildObjectMapRequest<I>::send_trim_image() {
   uint64_t orig_size;
   {
     RWLock::RLocker l(m_image_ctx.snap_lock);
+    assert(m_image_ctx.object_map != nullptr);
+
     new_size = get_image_size();
     orig_size = m_image_ctx.get_object_size() *
-                m_image_ctx.object_map.size();
+                m_image_ctx.object_map->size();
   }
   TrimRequest<I> *req = new TrimRequest<I>(m_image_ctx,
                                            this->create_callback_context(),
@@ -325,7 +331,10 @@ void RebuildObjectMapRequest<I>::send_save_object_map() {
   // should have been canceled prior to releasing lock
   assert(m_image_ctx.exclusive_lock == nullptr ||
          m_image_ctx.exclusive_lock->is_lock_owner());
-  m_image_ctx.object_map.aio_save(this->create_callback_context());
+
+  RWLock::RLocker snap_locker(m_image_ctx.snap_lock);
+  assert(m_image_ctx.object_map != nullptr);
+  m_image_ctx.object_map->aio_save(this->create_callback_context());
 }
 
 template <typename I>
diff --git a/src/librbd/operation/ResizeRequest.cc b/src/librbd/operation/ResizeRequest.cc
index 597bfd5ae139..dc92dbeef34b 100644
--- a/src/librbd/operation/ResizeRequest.cc
+++ b/src/librbd/operation/ResizeRequest.cc
@@ -197,7 +197,10 @@ template <typename I>
 void ResizeRequest<I>::send_grow_object_map() {
   I &image_ctx = this->m_image_ctx;
   assert(image_ctx.owner_lock.is_locked());
-  if (!image_ctx.object_map.enabled()) {
+
+  image_ctx.snap_lock.get_read();
+  if (image_ctx.object_map == nullptr) {
+    image_ctx.snap_lock.put_read();
     send_update_header();
     return;
   }
@@ -211,15 +214,19 @@ void ResizeRequest<I>::send_grow_object_map() {
   assert(image_ctx.exclusive_lock == nullptr ||
          image_ctx.exclusive_lock->is_lock_owner());
 
-  image_ctx.object_map.aio_resize(m_new_size, OBJECT_NONEXISTENT,
-				  this->create_callback_context());
+  image_ctx.object_map->aio_resize(m_new_size, OBJECT_NONEXISTENT,
+				   this->create_callback_context());
+  image_ctx.snap_lock.put_read();
 }
 
 template <typename I>
 bool ResizeRequest<I>::send_shrink_object_map() {
   I &image_ctx = this->m_image_ctx;
   assert(image_ctx.owner_lock.is_locked());
-  if (!image_ctx.object_map.enabled() || m_new_size > m_original_size) {
+
+  image_ctx.snap_lock.get_read();
+  if (image_ctx.object_map == nullptr || m_new_size > m_original_size) {
+    image_ctx.snap_lock.put_read();
     return true;
   }
 
@@ -232,8 +239,9 @@ bool ResizeRequest<I>::send_shrink_object_map() {
   assert(image_ctx.exclusive_lock == nullptr ||
          image_ctx.exclusive_lock->is_lock_owner());
 
-  image_ctx.object_map.aio_resize(m_new_size, OBJECT_NONEXISTENT,
-				  this->create_callback_context());
+  image_ctx.object_map->aio_resize(m_new_size, OBJECT_NONEXISTENT,
+				   this->create_callback_context());
+  image_ctx.snap_lock.put_read();
   return false;
 }
 
diff --git a/src/librbd/operation/SnapshotCreateRequest.cc b/src/librbd/operation/SnapshotCreateRequest.cc
index 7c659ec07244..63f19d48385b 100644
--- a/src/librbd/operation/SnapshotCreateRequest.cc
+++ b/src/librbd/operation/SnapshotCreateRequest.cc
@@ -222,13 +222,13 @@ bool SnapshotCreateRequest<I>::send_create_object_map() {
   {
     RWLock::RLocker snap_locker(image_ctx.snap_lock);
     RWLock::RLocker object_map_lock(image_ctx.object_map_lock);
-    if (image_ctx.object_map.enabled(image_ctx.object_map_lock)) {
+    if (image_ctx.object_map != nullptr) {
       CephContext *cct = image_ctx.cct;
       ldout(cct, 5) << this << " " << __func__ << dendl;
       m_state = STATE_CREATE_OBJECT_MAP;
 
-      image_ctx.object_map.snapshot_add(m_snap_id,
-                                        this->create_callback_context());
+      image_ctx.object_map->snapshot_add(m_snap_id,
+                                         this->create_callback_context());
       return false;
     }
   }
diff --git a/src/librbd/operation/SnapshotRemoveRequest.cc b/src/librbd/operation/SnapshotRemoveRequest.cc
index 9d5ff3897aa2..a227be446f3b 100644
--- a/src/librbd/operation/SnapshotRemoveRequest.cc
+++ b/src/librbd/operation/SnapshotRemoveRequest.cc
@@ -100,12 +100,12 @@ void SnapshotRemoveRequest<I>::send_remove_object_map() {
   {
     RWLock::WLocker snap_locker(image_ctx.snap_lock);
     RWLock::RLocker object_map_locker(image_ctx.object_map_lock);
-    if (image_ctx.object_map.enabled(image_ctx.object_map_lock)) {
+    if (image_ctx.object_map != nullptr) {
       CephContext *cct = image_ctx.cct;
       ldout(cct, 5) << this << " " << __func__ << dendl;
       m_state = STATE_REMOVE_OBJECT_MAP;
 
-      image_ctx.object_map.snapshot_remove(
+      image_ctx.object_map->snapshot_remove(
         m_snap_id, this->create_callback_context());
       return;
     }
diff --git a/src/librbd/operation/SnapshotRollbackRequest.cc b/src/librbd/operation/SnapshotRollbackRequest.cc
index 39770142d7cb..a0cb47cb85f5 100644
--- a/src/librbd/operation/SnapshotRollbackRequest.cc
+++ b/src/librbd/operation/SnapshotRollbackRequest.cc
@@ -163,12 +163,13 @@ void SnapshotRollbackRequest<I>::send_rollback_object_map() {
   {
     RWLock::RLocker snap_locker(image_ctx.snap_lock);
     RWLock::WLocker object_map_lock(image_ctx.object_map_lock);
-    if (image_ctx.object_map.enabled(image_ctx.object_map_lock)) {
+    if (image_ctx.object_map != nullptr) {
       CephContext *cct = image_ctx.cct;
       ldout(cct, 5) << this << " " << __func__ << dendl;
       m_state = STATE_ROLLBACK_OBJECT_MAP;
 
-      image_ctx.object_map.rollback(m_snap_id, this->create_callback_context());
+      image_ctx.object_map->rollback(m_snap_id,
+                                     this->create_callback_context());
       return;
     }
   }
diff --git a/src/librbd/operation/TrimRequest.cc b/src/librbd/operation/TrimRequest.cc
index 3deae0846578..8e32f3ec593c 100644
--- a/src/librbd/operation/TrimRequest.cc
+++ b/src/librbd/operation/TrimRequest.cc
@@ -70,8 +70,13 @@ public:
     assert(image_ctx.owner_lock.is_locked());
     assert(image_ctx.exclusive_lock == nullptr ||
            image_ctx.exclusive_lock->is_lock_owner());
-    if (!image_ctx.object_map.object_may_exist(m_object_no)) {
-      return 1;
+
+    {
+      RWLock::RLocker snap_locker(image_ctx.snap_lock);
+      if (image_ctx.object_map != nullptr &&
+          !image_ctx.object_map->object_may_exist(m_object_no)) {
+        return 1;
+      }
     }
 
     string oid = image_ctx.get_object_name(m_object_no);
@@ -251,7 +256,7 @@ void TrimRequest<I>::send_pre_remove() {
   bool remove_objects = false;
   {
     RWLock::RLocker snap_locker(image_ctx.snap_lock);
-    if (!image_ctx.object_map.enabled()) {
+    if (image_ctx.object_map == nullptr) {
       remove_objects = true;
     } else {
       ldout(image_ctx.cct, 5) << this << " send_pre_remove: "
@@ -264,9 +269,9 @@ void TrimRequest<I>::send_pre_remove() {
       // flag the objects as pending deletion
       Context *ctx = this->create_callback_context();
       RWLock::WLocker object_map_locker(image_ctx.object_map_lock);
-      if (!image_ctx.object_map.aio_update(m_delete_start, m_num_objects,
-					     OBJECT_PENDING, OBJECT_EXISTS,
-                                             ctx)) {
+      if (!image_ctx.object_map->aio_update(m_delete_start, m_num_objects,
+					    OBJECT_PENDING, OBJECT_EXISTS,
+                                            ctx)) {
         delete ctx;
         remove_objects = true;
       }
@@ -288,7 +293,7 @@ void TrimRequest<I>::send_post_remove() {
   bool clean_boundary = false;
   {
     RWLock::RLocker snap_locker(image_ctx.snap_lock);
-    if (!image_ctx.object_map.enabled()) {
+    if (image_ctx.object_map == nullptr) {
       clean_boundary = true;
     } else {
       ldout(image_ctx.cct, 5) << this << " send_post_remove: "
@@ -301,9 +306,9 @@ void TrimRequest<I>::send_post_remove() {
       // flag the pending objects as removed
       Context *ctx = this->create_callback_context();
       RWLock::WLocker object_map_locker(image_ctx.object_map_lock);
-      if (!image_ctx.object_map.aio_update(m_delete_start, m_num_objects,
-					     OBJECT_NONEXISTENT,
-					     OBJECT_PENDING, ctx)) {
+      if (!image_ctx.object_map->aio_update(m_delete_start, m_num_objects,
+					    OBJECT_NONEXISTENT,
+					    OBJECT_PENDING, ctx)) {
         delete ctx;
 	clean_boundary = true;
       }