import 15.2.0 Octopus source

[ceph.git] / ceph / src / librbd / DeepCopyRequest.cc

diff --git a/ceph/src/librbd/DeepCopyRequest.cc b/ceph/src/librbd/DeepCopyRequest.cc
index 1d56b255d4cbab2e0021b6ffdd20cd6475b9f370..90fde47b71dbf9dc0ed9a618ae9c5865be15189c 100644 (file)
--- a/ceph/src/librbd/DeepCopyRequest.cc
+++ b/ceph/src/librbd/DeepCopyRequest.cc
@@ -27,19 +27,21 @@ using librbd::util::unique_lock_name;
 
 template <typename I>
 DeepCopyRequest<I>::DeepCopyRequest(I *src_image_ctx, I *dst_image_ctx,
-                                    librados::snap_t snap_id_start,
-                                    librados::snap_t snap_id_end, bool flatten,
+                                    librados::snap_t src_snap_id_start,
+                                    librados::snap_t src_snap_id_end,
+                                    librados::snap_t dst_snap_id_start,
+                                    bool flatten,
                                     const ObjectNumber &object_number,
                                     ContextWQ *work_queue, SnapSeqs *snap_seqs,
                                     ProgressContext *prog_ctx,
                                     Context *on_finish)
-  : RefCountedObject(dst_image_ctx->cct, 1), m_src_image_ctx(src_image_ctx),
-    m_dst_image_ctx(dst_image_ctx), m_snap_id_start(snap_id_start),
-    m_snap_id_end(snap_id_end), m_flatten(flatten),
-    m_object_number(object_number), m_work_queue(work_queue),
-    m_snap_seqs(snap_seqs), m_prog_ctx(prog_ctx), m_on_finish(on_finish),
-    m_cct(dst_image_ctx->cct),
-    m_lock(unique_lock_name("DeepCopyRequest::m_lock", this)) {
+  : RefCountedObject(dst_image_ctx->cct), m_src_image_ctx(src_image_ctx),
+    m_dst_image_ctx(dst_image_ctx), m_src_snap_id_start(src_snap_id_start),
+    m_src_snap_id_end(src_snap_id_end), m_dst_snap_id_start(dst_snap_id_start),
+    m_flatten(flatten), m_object_number(object_number),
+    m_work_queue(work_queue), m_snap_seqs(snap_seqs), m_prog_ctx(prog_ctx),
+    m_on_finish(on_finish), m_cct(dst_image_ctx->cct),
+    m_lock(ceph::make_mutex(unique_lock_name("DeepCopyRequest::m_lock", this))) {
 }
 
 template <typename I>
@@ -73,7 +75,7 @@ void DeepCopyRequest<I>::send() {
 
 template <typename I>
 void DeepCopyRequest<I>::cancel() {
-  Mutex::Locker locker(m_lock);
+  std::lock_guard locker{m_lock};
 
   ldout(m_cct, 20) << dendl;
 
@@ -90,9 +92,9 @@ void DeepCopyRequest<I>::cancel() {
 
 template <typename I>
 void DeepCopyRequest<I>::send_copy_snapshots() {
-  m_lock.Lock();
+  m_lock.lock();
   if (m_canceled) {
-    m_lock.Unlock();
+    m_lock.unlock();
     finish(-ECANCELED);
     return;
   }
@@ -102,10 +104,10 @@ void DeepCopyRequest<I>::send_copy_snapshots() {
   Context *ctx = create_context_callback<
     DeepCopyRequest<I>, &DeepCopyRequest<I>::handle_copy_snapshots>(this);
   m_snapshot_copy_request = SnapshotCopyRequest<I>::create(
-    m_src_image_ctx, m_dst_image_ctx, m_snap_id_end, m_flatten, m_work_queue,
-    m_snap_seqs, ctx);
+    m_src_image_ctx, m_dst_image_ctx, m_src_snap_id_start, m_src_snap_id_end,
+    m_dst_snap_id_start, m_flatten, m_work_queue, m_snap_seqs, ctx);
   m_snapshot_copy_request->get();
-  m_lock.Unlock();
+  m_lock.unlock();
 
   m_snapshot_copy_request->send();
 }
@@ -115,7 +117,7 @@ void DeepCopyRequest<I>::handle_copy_snapshots(int r) {
   ldout(m_cct, 20) << "r=" << r << dendl;
 
   {
-    Mutex::Locker locker(m_lock);
+    std::lock_guard locker{m_lock};
     m_snapshot_copy_request->put();
     m_snapshot_copy_request = nullptr;
     if (r == 0 && m_canceled) {
@@ -134,7 +136,7 @@ void DeepCopyRequest<I>::handle_copy_snapshots(int r) {
     return;
   }
 
-  if (m_snap_id_end == CEPH_NOSNAP) {
+  if (m_src_snap_id_end == CEPH_NOSNAP) {
     (*m_snap_seqs)[CEPH_NOSNAP] = CEPH_NOSNAP;
   }
 
@@ -143,9 +145,9 @@ void DeepCopyRequest<I>::handle_copy_snapshots(int r) {
 
 template <typename I>
 void DeepCopyRequest<I>::send_copy_image() {
-  m_lock.Lock();
+  m_lock.lock();
   if (m_canceled) {
-    m_lock.Unlock();
+    m_lock.unlock();
     finish(-ECANCELED);
     return;
   }
@@ -155,10 +157,11 @@ void DeepCopyRequest<I>::send_copy_image() {
   Context *ctx = create_context_callback<
     DeepCopyRequest<I>, &DeepCopyRequest<I>::handle_copy_image>(this);
   m_image_copy_request = ImageCopyRequest<I>::create(
-      m_src_image_ctx, m_dst_image_ctx, m_snap_id_start, m_snap_id_end,
-      m_flatten, m_object_number, *m_snap_seqs, m_prog_ctx, ctx);
+    m_src_image_ctx, m_dst_image_ctx, m_src_snap_id_start, m_src_snap_id_end,
+    m_dst_snap_id_start, m_flatten, m_object_number, *m_snap_seqs, m_prog_ctx,
+    ctx);
   m_image_copy_request->get();
-  m_lock.Unlock();
+  m_lock.unlock();
 
   m_image_copy_request->send();
 }
@@ -168,7 +171,7 @@ void DeepCopyRequest<I>::handle_copy_image(int r) {
   ldout(m_cct, 20) << "r=" << r << dendl;
 
   {
-    Mutex::Locker locker(m_lock);
+    std::lock_guard locker{m_lock};
     m_image_copy_request->put();
     m_image_copy_request = nullptr;
     if (r == 0 && m_canceled) {
@@ -191,19 +194,19 @@ void DeepCopyRequest<I>::handle_copy_image(int r) {
 
 template <typename I>
 void DeepCopyRequest<I>::send_copy_object_map() {
-  m_dst_image_ctx->owner_lock.get_read();
-  m_dst_image_ctx->snap_lock.get_read();
+  m_dst_image_ctx->owner_lock.lock_shared();
+  m_dst_image_ctx->image_lock.lock_shared();
 
   if (!m_dst_image_ctx->test_features(RBD_FEATURE_OBJECT_MAP,
-                                      m_dst_image_ctx->snap_lock)) {
-    m_dst_image_ctx->snap_lock.put_read();
-    m_dst_image_ctx->owner_lock.put_read();
+                                      m_dst_image_ctx->image_lock)) {
+    m_dst_image_ctx->image_lock.unlock_shared();
+    m_dst_image_ctx->owner_lock.unlock_shared();
     send_copy_metadata();
     return;
   }
-  if (m_snap_id_end == CEPH_NOSNAP) {
-    m_dst_image_ctx->snap_lock.put_read();
-    m_dst_image_ctx->owner_lock.put_read();
+  if (m_src_snap_id_end == CEPH_NOSNAP) {
+    m_dst_image_ctx->image_lock.unlock_shared();
+    m_dst_image_ctx->owner_lock.unlock_shared();
     send_refresh_object_map();
     return;
   }
@@ -219,23 +222,22 @@ void DeepCopyRequest<I>::send_copy_object_map() {
   }
   if (finish_op_ctx == nullptr) {
     lderr(m_cct) << "lost exclusive lock" << dendl;
-    m_dst_image_ctx->snap_lock.put_read();
-    m_dst_image_ctx->owner_lock.put_read();
+    m_dst_image_ctx->image_lock.unlock_shared();
+    m_dst_image_ctx->owner_lock.unlock_shared();
     finish(r);
     return;
   }
 
   // rollback the object map (copy snapshot object map to HEAD)
-  RWLock::WLocker object_map_locker(m_dst_image_ctx->object_map_lock);
-  auto ctx = new FunctionContext([this, finish_op_ctx](int r) {
+  auto ctx = new LambdaContext([this, finish_op_ctx](int r) {
       handle_copy_object_map(r);
       finish_op_ctx->complete(0);
     });
-  ceph_assert(m_snap_seqs->count(m_snap_id_end) > 0);
-  librados::snap_t copy_snap_id = (*m_snap_seqs)[m_snap_id_end];
+  ceph_assert(m_snap_seqs->count(m_src_snap_id_end) > 0);
+  librados::snap_t copy_snap_id = (*m_snap_seqs)[m_src_snap_id_end];
   m_dst_image_ctx->object_map->rollback(copy_snap_id, ctx);
-  m_dst_image_ctx->snap_lock.put_read();
-  m_dst_image_ctx->owner_lock.put_read();
+  m_dst_image_ctx->image_lock.unlock_shared();
+  m_dst_image_ctx->owner_lock.unlock_shared();
 }
 
 template <typename I>
@@ -257,7 +259,7 @@ void DeepCopyRequest<I>::send_refresh_object_map() {
   int r;
   Context *finish_op_ctx = nullptr;
   {
-    RWLock::RLocker owner_locker(m_dst_image_ctx->owner_lock);
+    std::shared_lock owner_locker{m_dst_image_ctx->owner_lock};
     if (m_dst_image_ctx->exclusive_lock != nullptr) {
       finish_op_ctx = m_dst_image_ctx->exclusive_lock->start_op(&r);
     }
@@ -270,7 +272,7 @@ void DeepCopyRequest<I>::send_refresh_object_map() {
 
   ldout(m_cct, 20) << dendl;
 
-  auto ctx = new FunctionContext([this, finish_op_ctx](int r) {
+  auto ctx = new LambdaContext([this, finish_op_ctx](int r) {
       handle_refresh_object_map(r);
       finish_op_ctx->complete(0);
     });
@@ -292,11 +294,10 @@ void DeepCopyRequest<I>::handle_refresh_object_map(int r) {
   }
 
   {
-    RWLock::WLocker snap_locker(m_dst_image_ctx->snap_lock);
-    RWLock::WLocker object_map_locker(m_dst_image_ctx->object_map_lock);
+    std::unique_lock image_locker{m_dst_image_ctx->image_lock};
     std::swap(m_dst_image_ctx->object_map, m_object_map);
   }
-  delete m_object_map;
+  m_object_map->put();
 
   send_copy_metadata();
 }
@@ -327,19 +328,19 @@ void DeepCopyRequest<I>::handle_copy_metadata(int r) {
 
 template <typename I>
 int DeepCopyRequest<I>::validate_copy_points() {
-  RWLock::RLocker snap_locker(m_src_image_ctx->snap_lock);
+  std::shared_lock image_locker{m_src_image_ctx->image_lock};
 
-  if (m_snap_id_start != 0 &&
-      m_src_image_ctx->snap_info.find(m_snap_id_start) ==
+  if (m_src_snap_id_start != 0 &&
+      m_src_image_ctx->snap_info.find(m_src_snap_id_start) ==
       m_src_image_ctx->snap_info.end()) {
-    lderr(m_cct) << "invalid start snap_id " << m_snap_id_start << dendl;
+    lderr(m_cct) << "invalid start snap_id " << m_src_snap_id_start << dendl;
     return -EINVAL;
   }
 
-  if (m_snap_id_end != CEPH_NOSNAP &&
-      m_src_image_ctx->snap_info.find(m_snap_id_end) ==
+  if (m_src_snap_id_end != CEPH_NOSNAP &&
+      m_src_image_ctx->snap_info.find(m_src_snap_id_end) ==
       m_src_image_ctx->snap_info.end()) {
-    lderr(m_cct) << "invalid end snap_id " << m_snap_id_end << dendl;
+    lderr(m_cct) << "invalid end snap_id " << m_src_snap_id_end << dendl;
     return -EINVAL;
   }