librbd: removed 'ImageCtx::parent_lock'

The ImageCtx parent-related data structures are now protected
by the image_lock.

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

diff --git a/src/librbd/ImageCtx.cc b/src/librbd/ImageCtx.cc
index b1c81ed8d48d189030470b56f0e96d99c7a242f1..556b1dba9077c66448ff7f01df9f4a700ab03dba 100644 (file)
--- a/src/librbd/ImageCtx.cc
+++ b/src/librbd/ImageCtx.cc
@@ -107,7 +107,6 @@ public:
       journal(NULL),
       owner_lock(util::unique_lock_name("librbd::ImageCtx::owner_lock", this)),
       image_lock(util::unique_lock_name("librbd::ImageCtx::image_lock", this)),
-      parent_lock(util::unique_lock_name("librbd::ImageCtx::parent_lock", this)),
       timestamp_lock(util::unique_lock_name("librbd::ImageCtx::timestamp_lock", this)),
       async_ops_lock(util::unique_lock_name("librbd::ImageCtx::async_ops_lock", this)),
       copyup_list_lock(util::unique_lock_name("librbd::ImageCtx::copyup_list_lock", this)),
@@ -619,7 +618,6 @@ public:
   const ParentImageInfo* ImageCtx::get_parent_info(snap_t in_snap_id) const
   {
     ceph_assert(image_lock.is_locked());
-    ceph_assert(parent_lock.is_locked());
     if (in_snap_id == CEPH_NOSNAP)
       return &parent_md;
     const SnapInfo *info = get_snap_info(in_snap_id);

diff --git a/src/librbd/ImageCtx.h b/src/librbd/ImageCtx.h
index 0adf860d71bb69b61d62d57b1c1c98b46086be63..2f2047ff594f4471da71a90cc5f426337fc3835b 100644 (file)
--- a/src/librbd/ImageCtx.h
+++ b/src/librbd/ImageCtx.h
@@ -98,7 +98,7 @@ namespace librbd {
     /**
      * Lock ordering:
      *
-     * owner_lock, image_lock, parent_lock,
+     * owner_lock, image_lock
      * async_op_lock, timestamp_lock
      */
     RWLock owner_lock; // protects exclusive lock leadership updates
@@ -113,7 +113,7 @@ namespace librbd {
                        // lock_tag
                        // lockers
                        // object_map
-    RWLock parent_lock; // protects parent_md and parent
+                       // parent_md and parent
 
     RWLock timestamp_lock; // protects (create/access/modify)_timestamp
     Mutex async_ops_lock; // protects async_ops and async_requests

diff --git a/src/librbd/Operations.cc b/src/librbd/Operations.cc
index 205f3d08e0f837176eb8fc9c8b66682b65434561..eaee012350e1b8eb8b9c7cfe2fa4221235a5ca2e 100644 (file)
--- a/src/librbd/Operations.cc
+++ b/src/librbd/Operations.cc
@@ -348,7 +348,7 @@ int Operations<I>::flatten(ProgressContext &prog_ctx) {
   }
 
   {
-    RWLock::RLocker parent_locker(m_image_ctx.parent_lock);
+    RWLock::RLocker image_locker(m_image_ctx.image_lock);
     if (m_image_ctx.parent_md.spec.pool_id == -1) {
       lderr(cct) << "image has no parent" << dendl;
       return -EINVAL;
@@ -386,19 +386,16 @@ void Operations<I>::execute_flatten(ProgressContext &prog_ctx,
   }
 
   m_image_ctx.image_lock.get_read();
-  m_image_ctx.parent_lock.get_read();
 
   // can't flatten a non-clone
   if (m_image_ctx.parent_md.spec.pool_id == -1) {
     lderr(cct) << "image has no parent" << dendl;
-    m_image_ctx.parent_lock.put_read();
     m_image_ctx.image_lock.put_read();
     on_finish->complete(-EINVAL);
     return;
   }
   if (m_image_ctx.snap_id != CEPH_NOSNAP) {
     lderr(cct) << "snapshots cannot be flattened" << dendl;
-    m_image_ctx.parent_lock.put_read();
     m_image_ctx.image_lock.put_read();
     on_finish->complete(-EROFS);
     return;
@@ -414,7 +411,6 @@ void Operations<I>::execute_flatten(ProgressContext &prog_ctx,
   uint64_t overlap_objects = Striper::get_num_objects(m_image_ctx.layout,
                                                       overlap);
 
-  m_image_ctx.parent_lock.put_read();
   m_image_ctx.image_lock.put_read();
 
   operation::FlattenRequest<I> *req = new operation::FlattenRequest<I>(
@@ -1575,7 +1571,7 @@ int Operations<I>::migrate(ProgressContext &prog_ctx) {
   }
 
   {
-    RWLock::RLocker parent_locker(m_image_ctx.parent_lock);
+    RWLock::RLocker image_locker(m_image_ctx.image_lock);
     if (m_image_ctx.migration_info.empty()) {
       lderr(cct) << "image has no migrating parent" << dendl;
       return -EINVAL;
@@ -1613,24 +1609,20 @@ void Operations<I>::execute_migrate(ProgressContext &prog_ctx,
   }
 
   m_image_ctx.image_lock.get_read();
-  m_image_ctx.parent_lock.get_read();
 
   if (m_image_ctx.migration_info.empty()) {
     lderr(cct) << "image has no migrating parent" << dendl;
-    m_image_ctx.parent_lock.put_read();
     m_image_ctx.image_lock.put_read();
     on_finish->complete(-EINVAL);
     return;
   }
   if (m_image_ctx.snap_id != CEPH_NOSNAP) {
     lderr(cct) << "snapshots cannot be migrated" << dendl;
-    m_image_ctx.parent_lock.put_read();
     m_image_ctx.image_lock.put_read();
     on_finish->complete(-EROFS);
     return;
   }
 
-  m_image_ctx.parent_lock.put_read();
   m_image_ctx.image_lock.put_read();
 
   operation::MigrateRequest<I> *req = new operation::MigrateRequest<I>(

diff --git a/src/librbd/api/DiffIterate.cc b/src/librbd/api/DiffIterate.cc
index 3e5f55eb1c9687ef8146c8ae3155cd35643bbba1..0c7b17cd582c6c81855783e3ee33a7123aae5569 100644 (file)
--- a/src/librbd/api/DiffIterate.cc
+++ b/src/librbd/api/DiffIterate.cc
@@ -330,8 +330,7 @@ int DiffIterate<I>::execute() {
   DiffContext diff_context(m_image_ctx, m_callback, m_callback_arg,
                            m_whole_object, from_snap_id, end_snap_id);
   if (m_include_parent && from_snap_id == 0) {
-    RWLock::RLocker l(m_image_ctx.image_lock);
-    RWLock::RLocker l2(m_image_ctx.parent_lock);
+    RWLock::RLocker image_locker(m_image_ctx.image_lock);
     uint64_t overlap = 0;
     m_image_ctx.get_parent_overlap(m_image_ctx.snap_id, &overlap);
     r = 0;

diff --git a/src/librbd/api/Image.cc b/src/librbd/api/Image.cc
index e32b4c7a397a9bac10eb468843fadcb6691a8755..78140565386ebe96335aad1cb7d870006a83cfb5 100644 (file)
--- a/src/librbd/api/Image.cc
+++ b/src/librbd/api/Image.cc
@@ -201,12 +201,10 @@ int Image<I>::get_parent(I *ictx,
   }
 
   RWLock::RLocker image_locker(ictx->image_lock);
-  RWLock::RLocker parent_locker(ictx->parent_lock);
 
-  bool release_parent_locks = false;
-  BOOST_SCOPE_EXIT_ALL(ictx, &release_parent_locks) {
-    if (release_parent_locks) {
-      ictx->parent->parent_lock.put_read();
+  bool release_image_lock = false;
+  BOOST_SCOPE_EXIT_ALL(ictx, &release_image_lock) {
+    if (release_image_lock) {
       ictx->parent->image_lock.put_read();
     }
   };
@@ -215,9 +213,8 @@ int Image<I>::get_parent(I *ictx,
   // of the migration source image
   auto parent = ictx->parent;
   if (!ictx->migration_info.empty() && ictx->parent != nullptr) {
-    release_parent_locks = true;
+    release_image_lock = true;
     ictx->parent->image_lock.get_read();
-    ictx->parent->parent_lock.get_read();
 
     parent = ictx->parent->parent;
   }
@@ -567,7 +564,6 @@ int Image<I>::deep_copy(I *src, librados::IoCtx& dest_md_ctx,
     parent_spec.pool_id = -1;
   } else {
     RWLock::RLocker image_locker(src->image_lock);
-    RWLock::RLocker parent_locker(src->parent_lock);
 
     // use oldest snapshot or HEAD for parent spec
     if (!src->snap_info.empty()) {

diff --git a/src/librbd/api/Migration.cc b/src/librbd/api/Migration.cc
index 90cda0b86baf0bc95576ebc3b03e8ad2b55ba6d8..b0d80c94a49bc91c38a019bc4432ea87f0bb7cf7 100644 (file)
--- a/src/librbd/api/Migration.cc
+++ b/src/librbd/api/Migration.cc
@@ -1194,7 +1194,6 @@ int Migration<I>::create_dst_image() {
   cls::rbd::ParentImageSpec parent_spec;
   {
     RWLock::RLocker image_locker(m_src_image_ctx->image_lock);
-    RWLock::RLocker parent_locker(m_src_image_ctx->parent_lock);
     size = m_src_image_ctx->size;
 
     // use oldest snapshot or HEAD for parent spec
@@ -1654,7 +1653,6 @@ int Migration<I>::relink_child(I *from_image_ctx, I *to_image_ctx,
   uint64_t parent_overlap;
   {
     RWLock::RLocker image_locker(child_image_ctx->image_lock);
-    RWLock::RLocker parent_locker(child_image_ctx->parent_lock);
 
     // use oldest snapshot or HEAD for parent spec
     if (!child_image_ctx->snap_info.empty()) {

diff --git a/src/librbd/api/Mirror.cc b/src/librbd/api/Mirror.cc
index 7b3c8a166e2b83072f2b48e9cede030c526e0f80..c5b34ab1228cbdf6b1695c644a30e61dfd69a4d3 100644 (file)
--- a/src/librbd/api/Mirror.cc
+++ b/src/librbd/api/Mirror.cc
@@ -194,7 +194,7 @@ int Mirror<I>::image_enable(I *ictx, bool relax_same_pool_parent_check) {
 
   // is mirroring not enabled for the parent?
   {
-    RWLock::RLocker l(ictx->parent_lock);
+    RWLock::RLocker image_locker(ictx->image_lock);
     ImageCtx *parent = ictx->parent;
     if (parent) {
       if (relax_same_pool_parent_check &&

diff --git a/src/librbd/cache/ObjectCacherWriteback.cc b/src/librbd/cache/ObjectCacherWriteback.cc
index 10414e64c3eacc186325666e6218c7ec1a1e5104..b6aed2a7db7f80d4e7cff616e2eaafec3e94af9a 100644 (file)
--- a/src/librbd/cache/ObjectCacherWriteback.cc
+++ b/src/librbd/cache/ObjectCacherWriteback.cc
@@ -149,10 +149,8 @@ bool ObjectCacherWriteback::may_copy_on_write(const object_t& oid,
 {
   m_ictx->image_lock.get_read();
   librados::snap_t snap_id = m_ictx->snap_id;
-  m_ictx->parent_lock.get_read();
   uint64_t overlap = 0;
   m_ictx->get_parent_overlap(snap_id, &overlap);
-  m_ictx->parent_lock.put_read();
   m_ictx->image_lock.put_read();
 
   uint64_t object_no = oid_to_object_no(oid.name, m_ictx->object_prefix);

diff --git a/src/librbd/deep_copy/ObjectCopyRequest.cc b/src/librbd/deep_copy/ObjectCopyRequest.cc
index 03517fb5a9a1b92b9892a0be81f1921a3eabad3b..3a1de0e1c75b4918bbb8226be097bac6e90a9dbc 100644 (file)
--- a/src/librbd/deep_copy/ObjectCopyRequest.cc
+++ b/src/librbd/deep_copy/ObjectCopyRequest.cc
@@ -225,13 +225,11 @@ void ObjectCopyRequest<I>::handle_read_object(int r) {
 template <typename I>
 void ObjectCopyRequest<I>::send_read_from_parent() {
   m_src_image_ctx->image_lock.get_read();
-  m_src_image_ctx->parent_lock.get_read();
   io::Extents image_extents;
   compute_read_from_parent_ops(&image_extents);
   m_src_image_ctx->image_lock.put_read();
 
   if (image_extents.empty()) {
-    m_src_image_ctx->parent_lock.put_read();
     handle_read_from_parent(0);
     return;
   }
@@ -252,7 +250,6 @@ void ObjectCopyRequest<I>::send_read_from_parent() {
                                 std::move(image_extents),
                                 io::ReadResult{&m_read_from_parent_data}, 0,
                                 ZTracer::Trace());
-  src_image_ctx->parent_lock.put_read();
 }
 
 template <typename I>
@@ -576,9 +573,9 @@ void ObjectCopyRequest<I>::compute_read_ops() {
   m_read_snaps = {};
   m_zero_interval = {};
 
-  m_src_image_ctx->parent_lock.get_read();
+  m_src_image_ctx->image_lock.get_read();
   bool hide_parent = (m_src_image_ctx->parent != nullptr);
-  m_src_image_ctx->parent_lock.put_read();
+  m_src_image_ctx->image_lock.put_read();
 
   librados::snap_t src_copy_point_snap_id = m_snap_map.rbegin()->first;
   bool prev_exists = hide_parent;
@@ -716,7 +713,6 @@ template <typename I>
 void ObjectCopyRequest<I>::compute_read_from_parent_ops(
     io::Extents *parent_image_extents) {
   assert(m_src_image_ctx->image_lock.is_locked());
-  assert(m_src_image_ctx->parent_lock.is_locked());
 
   m_read_ops = {};
   m_zero_interval = {};
@@ -849,9 +845,9 @@ void ObjectCopyRequest<I>::compute_zero_ops() {
   bool fast_diff = m_dst_image_ctx->test_features(RBD_FEATURE_FAST_DIFF);
   uint64_t prev_end_size = 0;
 
-  m_src_image_ctx->parent_lock.get_read();
+  m_src_image_ctx->image_lock.get_read();
   bool hide_parent = (m_src_image_ctx->parent != nullptr);
-  m_src_image_ctx->parent_lock.put_read();
+  m_src_image_ctx->image_lock.put_read();
 
   for (auto &it : m_dst_zero_interval) {
     auto src_snap_seq = it.first;
@@ -872,9 +868,9 @@ void ObjectCopyRequest<I>::compute_zero_ops() {
 
     if (hide_parent) {
       RWLock::RLocker image_locker(m_dst_image_ctx->image_lock);
-      RWLock::RLocker parent_locker(m_dst_image_ctx->parent_lock);
       uint64_t parent_overlap = 0;
-      int r = m_dst_image_ctx->get_parent_overlap(dst_snap_seq, &parent_overlap);
+      int r = m_dst_image_ctx->get_parent_overlap(dst_snap_seq,
+                                                  &parent_overlap);
       if (r < 0) {
         ldout(m_cct, 5) << "failed getting parent overlap for snap_id: "
                         << dst_snap_seq << ": " << cpp_strerror(r) << dendl;

diff --git a/src/librbd/deep_copy/SetHeadRequest.cc b/src/librbd/deep_copy/SetHeadRequest.cc
index 3d896ad06af838f8bf3d6426f190b225fa203d63..654ac33071dce353768be0e17f6b35fdd79b752f 100644 (file)
--- a/src/librbd/deep_copy/SetHeadRequest.cc
+++ b/src/librbd/deep_copy/SetHeadRequest.cc
@@ -89,7 +89,6 @@ void SetHeadRequest<I>::handle_set_size(int r) {
     // adjust in-memory image size now that it's updated on disk
     RWLock::WLocker image_locker(m_image_ctx->image_lock);
     if (m_image_ctx->size > m_size) {
-      RWLock::WLocker parent_locker(m_image_ctx->parent_lock);
       if (m_image_ctx->parent_md.spec.pool_id != -1 &&
           m_image_ctx->parent_md.overlap > m_size) {
         m_image_ctx->parent_md.overlap = m_size;
@@ -103,15 +102,15 @@ void SetHeadRequest<I>::handle_set_size(int r) {
 
 template <typename I>
 void SetHeadRequest<I>::send_detach_parent() {
-  m_image_ctx->parent_lock.get_read();
+  m_image_ctx->image_lock.get_read();
   if (m_image_ctx->parent_md.spec.pool_id == -1 ||
       (m_image_ctx->parent_md.spec == m_parent_spec &&
        m_image_ctx->parent_md.overlap == m_parent_overlap)) {
-    m_image_ctx->parent_lock.put_read();
+    m_image_ctx->image_lock.put_read();
     send_attach_parent();
     return;
   }
-  m_image_ctx->parent_lock.put_read();
+  m_image_ctx->image_lock.put_read();
 
   ldout(m_cct, 20) << dendl;
 
@@ -143,7 +142,7 @@ void SetHeadRequest<I>::handle_detach_parent(int r) {
 
   {
     // adjust in-memory parent now that it's updated on disk
-    RWLock::WLocker parent_locker(m_image_ctx->parent_lock);
+    RWLock::WLocker image_locker(m_image_ctx->image_lock);
     m_image_ctx->parent_md.spec = {};
     m_image_ctx->parent_md.overlap = 0;
   }
@@ -153,14 +152,14 @@ void SetHeadRequest<I>::handle_detach_parent(int r) {
 
 template <typename I>
 void SetHeadRequest<I>::send_attach_parent() {
-  m_image_ctx->parent_lock.get_read();
+  m_image_ctx->image_lock.get_read();
   if (m_image_ctx->parent_md.spec == m_parent_spec &&
       m_image_ctx->parent_md.overlap == m_parent_overlap) {
-    m_image_ctx->parent_lock.put_read();
+    m_image_ctx->image_lock.put_read();
     finish(0);
     return;
   }
-  m_image_ctx->parent_lock.put_read();
+  m_image_ctx->image_lock.put_read();
 
   ldout(m_cct, 20) << dendl;
 
@@ -193,7 +192,7 @@ void SetHeadRequest<I>::handle_attach_parent(int r) {
 
   {
     // adjust in-memory parent now that it's updated on disk
-    RWLock::WLocker parent_locker(m_image_ctx->parent_lock);
+    RWLock::WLocker image_locker(m_image_ctx->image_lock);
     m_image_ctx->parent_md.spec = m_parent_spec;
     m_image_ctx->parent_md.overlap = m_parent_overlap;
   }

diff --git a/src/librbd/image/DetachChildRequest.cc b/src/librbd/image/DetachChildRequest.cc
index 33f9c215cb924bc74a7e173db25de21c2fdf2a22..242f12165fc77639057a82dbd72f08939e52b94b 100644 (file)
--- a/src/librbd/image/DetachChildRequest.cc
+++ b/src/librbd/image/DetachChildRequest.cc
@@ -33,7 +33,6 @@ template <typename I>
 void DetachChildRequest<I>::send() {
   {
     RWLock::RLocker image_locker(m_image_ctx.image_lock);
-    RWLock::RLocker parent_locker(m_image_ctx.parent_lock);
 
     // use oldest snapshot or HEAD for parent spec
     if (!m_image_ctx.snap_info.empty()) {

diff --git a/src/librbd/image/RefreshParentRequest.cc b/src/librbd/image/RefreshParentRequest.cc
index e6b16e092c1e68da5d4ee6086c1885272b1fd5dd..02b99b902025405c9902acd2510be3a0b9c8380b 100644 (file)
--- a/src/librbd/image/RefreshParentRequest.cc
+++ b/src/librbd/image/RefreshParentRequest.cc
@@ -37,7 +37,6 @@ bool RefreshParentRequest<I>::is_refresh_required(
     I &child_image_ctx, const ParentImageInfo &parent_md,
     const MigrationInfo &migration_info) {
   ceph_assert(child_image_ctx.image_lock.is_locked());
-  ceph_assert(child_image_ctx.parent_lock.is_locked());
   return (is_open_required(child_image_ctx, parent_md, migration_info) ||
           is_close_required(child_image_ctx, parent_md, migration_info));
 }
@@ -91,7 +90,6 @@ void RefreshParentRequest<I>::send() {
 template <typename I>
 void RefreshParentRequest<I>::apply() {
   ceph_assert(m_child_image_ctx.image_lock.is_wlocked());
-  ceph_assert(m_child_image_ctx.parent_lock.is_wlocked());
   std::swap(m_child_image_ctx.parent, m_parent_image_ctx);
 }
 

diff --git a/src/librbd/image/RefreshRequest.cc b/src/librbd/image/RefreshRequest.cc
index 5b25b06994e20b98137761e43d9fa0abb4de5940..ca0bf904230b31a09a238fc1da5a26ad51046499 100644 (file)
--- a/src/librbd/image/RefreshRequest.cc
+++ b/src/librbd/image/RefreshRequest.cc
@@ -808,7 +808,6 @@ template <typename I>
 void RefreshRequest<I>::send_v2_refresh_parent() {
   {
     RWLock::RLocker image_locker(m_image_ctx.image_lock);
-    RWLock::RLocker parent_locker(m_image_ctx.parent_lock);
 
     ParentImageInfo parent_md;
     MigrationInfo migration_info;
@@ -1283,7 +1282,6 @@ void RefreshRequest<I>::apply() {
 
   RWLock::WLocker owner_locker(m_image_ctx.owner_lock);
   RWLock::WLocker image_locker(m_image_ctx.image_lock);
-  RWLock::WLocker parent_locker(m_image_ctx.parent_lock);
 
   m_image_ctx.size = m_size;
   m_image_ctx.lockers = m_lockers;

diff --git a/src/librbd/image/SetSnapRequest.cc b/src/librbd/image/SetSnapRequest.cc
index bf017e5ab0eca08af605d64f22e452b60aeac367..c8e029ff7aa05c5ff4c711e03371fab59f9b68b2 100644 (file)
--- a/src/librbd/image/SetSnapRequest.cc
+++ b/src/librbd/image/SetSnapRequest.cc
@@ -179,7 +179,6 @@ Context *SetSnapRequest<I>::send_refresh_parent(int *result) {
   bool refresh_parent;
   {
     RWLock::RLocker image_locker(m_image_ctx.image_lock);
-    RWLock::RLocker parent_locker(m_image_ctx.parent_lock);
 
     const auto parent_info = m_image_ctx.get_parent_info(m_snap_id);
     if (parent_info == nullptr) {
@@ -326,7 +325,6 @@ int SetSnapRequest<I>::apply() {
 
   RWLock::WLocker owner_locker(m_image_ctx.owner_lock);
   RWLock::WLocker image_locker(m_image_ctx.image_lock);
-  RWLock::WLocker parent_locker(m_image_ctx.parent_lock);
   if (m_snap_id != CEPH_NOSNAP) {
     ceph_assert(m_image_ctx.exclusive_lock == nullptr);
     int r = m_image_ctx.snap_set(m_snap_id);

diff --git a/src/librbd/internal.cc b/src/librbd/internal.cc
index 45fefd16aefc53515a645106053f33ebd31f0725..a40649ae4c1ba8a98d3d2efe49c99e86b95ad463 100644 (file)
--- a/src/librbd/internal.cc
+++ b/src/librbd/internal.cc
@@ -973,8 +973,7 @@ int validate_pool(IoCtx &io_ctx, CephContext *cct) {
     int r = ictx->state->refresh_if_required();
     if (r < 0)
       return r;
-    RWLock::RLocker l(ictx->image_lock);
-    RWLock::RLocker l2(ictx->parent_lock);
+    RWLock::RLocker image_locker(ictx->image_lock);
     return ictx->get_parent_overlap(ictx->snap_id, overlap);
   }
 

diff --git a/src/librbd/io/CopyupRequest.cc b/src/librbd/io/CopyupRequest.cc
index cf29df82accc411515e36eb26782d1fd07003bd1..4128a40a9e438f7b05380fa80f8170434fd7d2fd 100644 (file)
--- a/src/librbd/io/CopyupRequest.cc
+++ b/src/librbd/io/CopyupRequest.cc
@@ -149,7 +149,6 @@ template <typename I>
 void CopyupRequest<I>::read_from_parent() {
   auto cct = m_image_ctx->cct;
   RWLock::RLocker image_locker(m_image_ctx->image_lock);
-  RWLock::RLocker parent_locker(m_image_ctx->parent_lock);
 
   if (m_image_ctx->parent == nullptr) {
     ldout(cct, 5) << "parent detached" << dendl;
@@ -224,7 +223,6 @@ template <typename I>
 void CopyupRequest<I>::deep_copy() {
   auto cct = m_image_ctx->cct;
   ceph_assert(m_image_ctx->image_lock.is_locked());
-  ceph_assert(m_image_ctx->parent_lock.is_locked());
   ceph_assert(m_image_ctx->parent != nullptr);
 
   m_lock.Lock();
@@ -589,7 +587,6 @@ void CopyupRequest<I>::compute_deep_copy_snap_ids() {
     }
   }
 
-  RWLock::RLocker parent_locker(m_image_ctx->parent_lock);
   std::copy_if(m_image_ctx->snaps.rbegin(), m_image_ctx->snaps.rend(),
                std::back_inserter(m_snap_ids),
                [this, cct=m_image_ctx->cct, &deep_copied](uint64_t snap_id) {

diff --git a/src/librbd/io/ObjectRequest.cc b/src/librbd/io/ObjectRequest.cc
index 90016674450554312a385def48de325525b20501..43766b71e0a3dea9a62aa74e432419c3a70453db 100644 (file)
--- a/src/librbd/io/ObjectRequest.cc
+++ b/src/librbd/io/ObjectRequest.cc
@@ -134,7 +134,6 @@ template <typename I>
 bool ObjectRequest<I>::compute_parent_extents(Extents *parent_extents,
                                               bool read_request) {
   ceph_assert(m_ictx->image_lock.is_locked());
-  ceph_assert(m_ictx->parent_lock.is_locked());
 
   m_has_parent = false;
   parent_extents->clear();
@@ -267,7 +266,6 @@ void ObjectReadRequest<I>::read_parent() {
   I *image_ctx = this->m_ictx;
 
   RWLock::RLocker image_locker(image_ctx->image_lock);
-  RWLock::RLocker parent_locker(image_ctx->parent_lock);
 
   // calculate reverse mapping onto the image
   Extents parent_extents;
@@ -284,7 +282,6 @@ void ObjectReadRequest<I>::read_parent() {
   }
 
   if (object_overlap == 0) {
-    parent_locker.unlock();
     image_locker.unlock();
 
     this->finish(-ENOENT);
@@ -329,12 +326,10 @@ void ObjectReadRequest<I>::copyup() {
 
   image_ctx->owner_lock.get_read();
   image_ctx->image_lock.get_read();
-  image_ctx->parent_lock.get_read();
   Extents parent_extents;
   if (!this->compute_parent_extents(&parent_extents, true) ||
       (image_ctx->exclusive_lock != nullptr &&
        !image_ctx->exclusive_lock->is_lock_owner())) {
-    image_ctx->parent_lock.put_read();
     image_ctx->image_lock.put_read();
     image_ctx->owner_lock.put_read();
     this->finish(0);
@@ -353,12 +348,10 @@ void ObjectReadRequest<I>::copyup() {
 
     image_ctx->copyup_list[this->m_object_no] = new_req;
     image_ctx->copyup_list_lock.Unlock();
-    image_ctx->parent_lock.put_read();
     image_ctx->image_lock.put_read();
     new_req->send();
   } else {
     image_ctx->copyup_list_lock.Unlock();
-    image_ctx->parent_lock.put_read();
     image_ctx->image_lock.put_read();
   }
 
@@ -397,7 +390,6 @@ template <typename I>
 void AbstractObjectWriteRequest<I>::compute_parent_info() {
   I *image_ctx = this->m_ictx;
   RWLock::RLocker image_locker(image_ctx->image_lock);
-  RWLock::RLocker parent_locker(image_ctx->parent_lock);
 
   this->compute_parent_extents(&m_parent_extents, false);
 

diff --git a/src/librbd/operation/FlattenRequest.cc b/src/librbd/operation/FlattenRequest.cc
index 7656e7b6cd1e6ce4ffffd3250234a7f383c7930e..268d244d995185304ed318f8bb74911e71a0acb8 100644 (file)
--- a/src/librbd/operation/FlattenRequest.cc
+++ b/src/librbd/operation/FlattenRequest.cc
@@ -191,15 +191,15 @@ void FlattenRequest<I>::detach_parent() {
 
   // stop early if the parent went away - it just means
   // another flatten finished first, so this one is useless.
-  image_ctx.parent_lock.get_read();
+  image_ctx.image_lock.get_read();
   if (!image_ctx.parent) {
     ldout(cct, 5) << "image already flattened" << dendl;
-    image_ctx.parent_lock.put_read();
+    image_ctx.image_lock.put_read();
     image_ctx.owner_lock.put_read();
     this->complete(0);
     return;
   }
-  image_ctx.parent_lock.put_read();
+  image_ctx.image_lock.put_read();
 
   // remove parent from this (base) image
   auto ctx = create_context_callback<

diff --git a/src/librbd/operation/MigrateRequest.cc b/src/librbd/operation/MigrateRequest.cc
index 2884961490b5f13c3231fc719ff35f8adda5939e..9be157cdf5a6a9a9ac57bb8d102b98a25334c8e3 100644 (file)
--- a/src/librbd/operation/MigrateRequest.cc
+++ b/src/librbd/operation/MigrateRequest.cc
@@ -221,7 +221,6 @@ uint64_t MigrateRequest<I>::get_num_overlap_objects() {
   ldout(cct, 10) << dendl;
 
   RWLock::RLocker image_locker(image_ctx.image_lock);
-  RWLock::RLocker parent_locker(image_ctx.parent_lock);
 
   auto overlap = image_ctx.migration_info.overlap;
 

diff --git a/src/librbd/operation/ResizeRequest.cc b/src/librbd/operation/ResizeRequest.cc
index 81fbd351ab8b9bf799c0afcbb1827e3d76747627..37b9a2ada72f7158679e0af948fbab79565cf6c5 100644 (file)
--- a/src/librbd/operation/ResizeRequest.cc
+++ b/src/librbd/operation/ResizeRequest.cc
@@ -433,7 +433,8 @@ Context *ResizeRequest<I>::handle_update_header(int *result) {
 template <typename I>
 void ResizeRequest<I>::compute_parent_overlap() {
   I &image_ctx = this->m_image_ctx;
-  RWLock::RLocker l2(image_ctx.parent_lock);
+  ceph_assert(image_ctx.image_lock.is_locked());
+
   if (image_ctx.parent == NULL) {
     m_new_parent_overlap = 0;
   } else {
@@ -448,7 +449,6 @@ void ResizeRequest<I>::update_size_and_overlap() {
     RWLock::WLocker image_locker(image_ctx.image_lock);
     image_ctx.size = m_new_size;
 
-    RWLock::WLocker parent_locker(image_ctx.parent_lock);
     if (image_ctx.parent != NULL && m_new_size < m_original_size) {
       image_ctx.parent_md.overlap = m_new_parent_overlap;
     }

diff --git a/src/librbd/operation/SnapshotCreateRequest.cc b/src/librbd/operation/SnapshotCreateRequest.cc
index 6945674410b6cf9e874dab2f45b08fbfe1cef098..e6d0e9b9b0ed5fd4588841a379d3a44e635e78c8 100644 (file)
--- a/src/librbd/operation/SnapshotCreateRequest.cc
+++ b/src/librbd/operation/SnapshotCreateRequest.cc
@@ -160,7 +160,6 @@ void SnapshotCreateRequest<I>::send_create_snap() {
 
   RWLock::RLocker owner_locker(image_ctx.owner_lock);
   RWLock::RLocker image_locker(image_ctx.image_lock);
-  RWLock::RLocker parent_locker(image_ctx.parent_lock);
 
   // should have been canceled prior to releasing lock
   ceph_assert(image_ctx.exclusive_lock == nullptr ||

diff --git a/src/librbd/operation/SnapshotRemoveRequest.cc b/src/librbd/operation/SnapshotRemoveRequest.cc
index feda957a02fee218dcbc5cb0227a817789222f7c..a7088687b4d4052dacb9629c64f1f2b31df371f8 100644 (file)
--- a/src/librbd/operation/SnapshotRemoveRequest.cc
+++ b/src/librbd/operation/SnapshotRemoveRequest.cc
@@ -159,7 +159,6 @@ void SnapshotRemoveRequest<I>::detach_child() {
   bool detach_child = false;
   {
     RWLock::RLocker image_locker(image_ctx.image_lock);
-    RWLock::RLocker parent_locker(image_ctx.parent_lock);
 
     cls::rbd::ParentImageSpec our_pspec;
     int r = image_ctx.get_parent_spec(m_snap_id, &our_pspec);
@@ -340,7 +339,6 @@ int SnapshotRemoveRequest<I>::scan_for_parents(
     cls::rbd::ParentImageSpec &pspec) {
   I &image_ctx = this->m_image_ctx;
   ceph_assert(image_ctx.image_lock.is_locked());
-  ceph_assert(image_ctx.parent_lock.is_locked());
 
   if (pspec.pool_id != -1) {
     map<uint64_t, SnapInfo>::iterator it;

diff --git a/src/librbd/operation/SparsifyRequest.cc b/src/librbd/operation/SparsifyRequest.cc
index 95f0cdc273130694d169995586a65934aa7a7506..537a0ca41eb88f7585b78276bcb0a7917d58e2d8 100644 (file)
--- a/src/librbd/operation/SparsifyRequest.cc
+++ b/src/librbd/operation/SparsifyRequest.cc
@@ -138,7 +138,6 @@ public:
         return 1;
       }
 
-      RWLock::RLocker parent_locker(image_ctx.parent_lock);
       uint64_t overlap_objects = 0;
       uint64_t overlap;
       int r = image_ctx.get_parent_overlap(CEPH_NOSNAP, &overlap);

diff --git a/src/librbd/operation/TrimRequest.cc b/src/librbd/operation/TrimRequest.cc
index b599872e9cce8b5b608ce81a2cf0c271017b4712..1b260953ea41abc1d46338f9a3b11a31cefd182e 100644 (file)
--- a/src/librbd/operation/TrimRequest.cc
+++ b/src/librbd/operation/TrimRequest.cc
@@ -218,7 +218,6 @@ void TrimRequest<I>::send_copyup_objects() {
   uint64_t parent_overlap;
   {
     RWLock::RLocker image_locker(image_ctx.image_lock);
-    RWLock::RLocker parent_locker(image_ctx.parent_lock);
 
     snapc = image_ctx.snapc;
     has_snapshots = !image_ctx.snaps.empty();

diff --git a/src/test/librbd/mock/MockImageCtx.h b/src/test/librbd/mock/MockImageCtx.h
index 9ecb609d6c78582e969e96653ab2cf17e358981a..00733d2e48a2134ac8b147e7f55a0532880dfbbb 100644 (file)
--- a/src/test/librbd/mock/MockImageCtx.h
+++ b/src/test/librbd/mock/MockImageCtx.h
@@ -63,7 +63,6 @@ struct MockImageCtx {
       owner_lock(image_ctx.owner_lock),
       image_lock(image_ctx.image_lock),
       timestamp_lock(image_ctx.timestamp_lock),
-      parent_lock(image_ctx.parent_lock),
       async_ops_lock(image_ctx.async_ops_lock),
       copyup_list_lock(image_ctx.copyup_list_lock),
       order(image_ctx.order),
@@ -248,7 +247,6 @@ struct MockImageCtx {
   RWLock &owner_lock;
   RWLock &image_lock;
   RWLock &timestamp_lock;
-  RWLock &parent_lock;
   Mutex &async_ops_lock;
   Mutex &copyup_list_lock;
 

diff --git a/src/test/librbd/object_map/test_mock_SnapshotCreateRequest.cc b/src/test/librbd/object_map/test_mock_SnapshotCreateRequest.cc
index dfccde317333556d2173434fb14e015acbe1731d..37a7ed3e7b7787dc7f8d2bf2fac4490dc6074fca 100644 (file)
--- a/src/test/librbd/object_map/test_mock_SnapshotCreateRequest.cc
+++ b/src/test/librbd/object_map/test_mock_SnapshotCreateRequest.cc
@@ -24,7 +24,6 @@ class TestMockObjectMapSnapshotCreateRequest : public TestMockFixture {
 public:
   void inject_snap_info(librbd::ImageCtx *ictx, uint64_t snap_id) {
     RWLock::WLocker image_locker(ictx->image_lock);
-    RWLock::RLocker parent_locker(ictx->parent_lock);
     ictx->add_snap(cls::rbd::UserSnapshotNamespace(), "snap name", snap_id,
                   ictx->size, ictx->parent_md,
                    RBD_PROTECTION_STATUS_UNPROTECTED, 0, utime_t());