librbd: refactor quiesce notify request

Generate request id inside notify request instead fo passing from
outside.

Signed-off-by: Mykola Golub <mgolub@suse.com>

diff --git a/src/librbd/ImageWatcher.cc b/src/librbd/ImageWatcher.cc
index 65c82a8ac4616711853858d7b56cc499547fd130..a2acaf9d6007456fa50dab527606a67ffce3d5c5 100644 (file)
--- a/src/librbd/ImageWatcher.cc
+++ b/src/librbd/ImageWatcher.cc
@@ -340,9 +340,10 @@ void ImageWatcher<I>::notify_header_update(librados::IoCtx &io_ctx,
 }
 
 template <typename I>
-void ImageWatcher<I>::notify_quiesce(uint64_t request_id,
-                                     ProgressContext &prog_ctx,
-                                     Context *on_finish) {
+uint64_t ImageWatcher<I>::notify_quiesce(ProgressContext &prog_ctx,
+                                         Context *on_finish) {
+  uint64_t request_id = m_image_ctx.operations->reserve_async_request_id();
+
   ldout(m_image_ctx.cct, 10) << this << " " << __func__ << ": request_id="
                              << request_id << dendl;
 
@@ -352,6 +353,8 @@ void ImageWatcher<I>::notify_quiesce(uint64_t request_id,
     "rbd_quiesce_notification_attempts");
 
   notify_quiesce(async_request_id, attempts, prog_ctx, on_finish);
+
+  return request_id;
 }
 
 template <typename I>

diff --git a/src/librbd/ImageWatcher.h b/src/librbd/ImageWatcher.h
index 130ba63541368e532d99112ac18facf62a25edfd..f141f4a6f24f49f5a52530a38266a6ccb836d392 100644 (file)
--- a/src/librbd/ImageWatcher.h
+++ b/src/librbd/ImageWatcher.h
@@ -72,8 +72,7 @@ public:
   static void notify_header_update(librados::IoCtx &io_ctx,
                                    const std::string &oid);
 
-  void notify_quiesce(uint64_t request_id, ProgressContext &prog_ctx,
-                      Context *on_finish);
+  uint64_t notify_quiesce(ProgressContext &prog_ctx, Context *on_finish);
   void notify_unquiesce(uint64_t request_id, Context *on_finish);
 
 private:

diff --git a/src/librbd/Operations.cc b/src/librbd/Operations.cc
index 3e31c71f8892018352ccec5babfbbfdafb81b2f3..43098d7764d65941e30181242d4a71c269b735aa 100644 (file)
--- a/src/librbd/Operations.cc
+++ b/src/librbd/Operations.cc
@@ -778,12 +778,10 @@ void Operations<I>::execute_snap_create(const cls::rbd::SnapshotNamespace &snap_
   }
   m_image_ctx.image_lock.unlock_shared();
 
-  uint64_t request_id = ++m_async_request_seq;
   operation::SnapshotCreateRequest<I> *req =
     new operation::SnapshotCreateRequest<I>(
       m_image_ctx, new C_NotifyUpdate<I>(m_image_ctx, on_finish),
-      snap_namespace, snap_name, journal_op_tid, request_id, skip_object_map,
-      prog_ctx);
+      snap_namespace, snap_name, journal_op_tid, skip_object_map, prog_ctx);
   req->send();
 }
 

diff --git a/src/librbd/Operations.h b/src/librbd/Operations.h
index 7c46dedb3aff65022a75e92f137bd7358b1aa2f7..b1fbfe1dd66ad1581101f558fd2e51121c3b9af9 100644 (file)
--- a/src/librbd/Operations.h
+++ b/src/librbd/Operations.h
@@ -24,6 +24,10 @@ class Operations {
 public:
   Operations(ImageCtxT &image_ctx);
 
+  uint64_t reserve_async_request_id() {
+    return ++m_async_request_seq;
+  }
+
   int flatten(ProgressContext &prog_ctx);
   void execute_flatten(ProgressContext &prog_ctx, Context *on_finish);
 
@@ -114,7 +118,7 @@ public:
 
 private:
   ImageCtxT &m_image_ctx;
-  std::atomic<int> m_async_request_seq;
+  std::atomic<uint64_t> m_async_request_seq;
 
   int invoke_async_request(const std::string& name,
                            exclusive_lock::OperationRequestType request_type,

diff --git a/src/librbd/operation/SnapshotCreateRequest.cc b/src/librbd/operation/SnapshotCreateRequest.cc
index 7a957b002159c158a35584d75d53b4612a79e82c..7c5f14244d861576f152e7675b768600fe33c09c 100644 (file)
--- a/src/librbd/operation/SnapshotCreateRequest.cc
+++ b/src/librbd/operation/SnapshotCreateRequest.cc
@@ -30,13 +30,11 @@ SnapshotCreateRequest<I>::SnapshotCreateRequest(I &image_ctx,
                                                const cls::rbd::SnapshotNamespace &snap_namespace,
                                                 const std::string &snap_name,
                                                 uint64_t journal_op_tid,
-                                                uint64_t request_id,
                                                 bool skip_object_map,
                                                 ProgressContext &prog_ctx)
   : Request<I>(image_ctx, on_finish, journal_op_tid),
     m_snap_namespace(snap_namespace), m_snap_name(snap_name),
-    m_request_id(request_id), m_skip_object_map(skip_object_map),
-    m_prog_ctx(prog_ctx) {
+    m_skip_object_map(skip_object_map), m_prog_ctx(prog_ctx) {
 }
 
 template <typename I>
@@ -60,8 +58,8 @@ void SnapshotCreateRequest<I>::send_notify_quiesce() {
   CephContext *cct = image_ctx.cct;
   ldout(cct, 5) << this << " " << __func__ << dendl;
 
-  image_ctx.image_watcher->notify_quiesce(
-    m_request_id, m_prog_ctx, create_async_context_callback(
+  m_request_id = image_ctx.image_watcher->notify_quiesce(
+    m_prog_ctx, create_async_context_callback(
       image_ctx, create_context_callback<SnapshotCreateRequest<I>,
       &SnapshotCreateRequest<I>::handle_notify_quiesce>(this)));
 }

diff --git a/src/librbd/operation/SnapshotCreateRequest.h b/src/librbd/operation/SnapshotCreateRequest.h
index c4840d38995e5ac45c7c94e7bea6114b32e5083b..544c04165c885e500673105d7ac00d32cf536e32 100644 (file)
--- a/src/librbd/operation/SnapshotCreateRequest.h
+++ b/src/librbd/operation/SnapshotCreateRequest.h
@@ -71,8 +71,7 @@ public:
   SnapshotCreateRequest(ImageCtxT &image_ctx, Context *on_finish,
                         const cls::rbd::SnapshotNamespace &snap_namespace,
                         const std::string &snap_name, uint64_t journal_op_tid,
-                        uint64_t request_id, bool skip_object_map,
-                        ProgressContext &prog_ctx);
+                        bool skip_object_map, ProgressContext &prog_ctx);
 
 protected:
   void send_op() override;
@@ -89,10 +88,10 @@ protected:
 private:
   cls::rbd::SnapshotNamespace m_snap_namespace;
   std::string m_snap_name;
-  uint64_t m_request_id;
   bool m_skip_object_map;
   ProgressContext &m_prog_ctx;
 
+  uint64_t m_request_id = 0;
   int m_ret_val = 0;
 
   uint64_t m_snap_id = CEPH_NOSNAP;

diff --git a/src/test/librbd/mock/MockImageWatcher.h b/src/test/librbd/mock/MockImageWatcher.h
index 0cca579b297a5b703238af885471d21fd3763a6a..f58bb2ba9622553ec9032147176d038b0e6050dd 100644 (file)
--- a/src/test/librbd/mock/MockImageWatcher.h
+++ b/src/test/librbd/mock/MockImageWatcher.h
@@ -25,7 +25,7 @@ struct MockImageWatcher {
   MOCK_METHOD0(notify_released_lock, void());
   MOCK_METHOD0(notify_request_lock, void());
 
-  MOCK_METHOD3(notify_quiesce, void(uint64_t, ProgressContext &, Context *));
+  MOCK_METHOD2(notify_quiesce, uint64_t(ProgressContext &, Context *));
   MOCK_METHOD2(notify_unquiesce, void(uint64_t, Context *));
 };
 

diff --git a/src/test/librbd/operation/test_mock_SnapshotCreateRequest.cc b/src/test/librbd/operation/test_mock_SnapshotCreateRequest.cc
index 650369748a5126e6801cd176881460d636471a13..c80f7627e6b8b09c750574591639316374bc41fe 100644 (file)
--- a/src/test/librbd/operation/test_mock_SnapshotCreateRequest.cc
+++ b/src/test/librbd/operation/test_mock_SnapshotCreateRequest.cc
@@ -63,9 +63,10 @@ public:
   typedef mirror::snapshot::SetImageStateRequest<MockImageCtx> MockSetImageStateRequest;
 
   void expect_notify_quiesce(MockImageCtx &mock_image_ctx, int r) {
-    EXPECT_CALL(*mock_image_ctx.image_watcher, notify_quiesce(_, _, _))
-      .WillOnce(WithArg<2>(
-                  CompleteContext(r, mock_image_ctx.image_ctx->op_work_queue)));
+    EXPECT_CALL(*mock_image_ctx.image_watcher, notify_quiesce(_, _))
+      .WillOnce(DoAll(WithArg<1>(CompleteContext(
+                                   r, mock_image_ctx.image_ctx->op_work_queue)),
+                      Return(0)));
   }
 
   void expect_block_writes(MockImageCtx &mock_image_ctx) {
@@ -187,7 +188,7 @@ TEST_F(TestMockOperationSnapshotCreateRequest, Success) {
   librbd::NoOpProgressContext prog_ctx;
   MockSnapshotCreateRequest *req = new MockSnapshotCreateRequest(
     mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(),
-    "snap1", 0, 0, false, prog_ctx);
+    "snap1", 0, false, prog_ctx);
   {
     std::shared_lock owner_locker{mock_image_ctx.owner_lock};
     req->send();
@@ -210,7 +211,7 @@ TEST_F(TestMockOperationSnapshotCreateRequest, NotifyQuiesceError) {
   librbd::NoOpProgressContext prog_ctx;
   MockSnapshotCreateRequest *req = new MockSnapshotCreateRequest(
     mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(),
-    "snap1", 0, 0, false, prog_ctx);
+    "snap1", 0, false, prog_ctx);
   {
     std::shared_lock owner_locker{mock_image_ctx.owner_lock};
     req->send();
@@ -243,7 +244,7 @@ TEST_F(TestMockOperationSnapshotCreateRequest, AllocateSnapIdError) {
   librbd::NoOpProgressContext prog_ctx;
   MockSnapshotCreateRequest *req = new MockSnapshotCreateRequest(
     mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(),
-    "snap1", 0, 0, false, prog_ctx);
+    "snap1", 0, false, prog_ctx);
   {
     std::shared_lock owner_locker{mock_image_ctx.owner_lock};
     req->send();
@@ -285,7 +286,7 @@ TEST_F(TestMockOperationSnapshotCreateRequest, CreateSnapStale) {
   librbd::NoOpProgressContext prog_ctx;
   MockSnapshotCreateRequest *req = new MockSnapshotCreateRequest(
     mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(),
-    "snap1", 0, 0, false, prog_ctx);
+    "snap1", 0, false, prog_ctx);
   {
     std::shared_lock owner_locker{mock_image_ctx.owner_lock};
     req->send();
@@ -319,7 +320,7 @@ TEST_F(TestMockOperationSnapshotCreateRequest, CreateSnapError) {
   librbd::NoOpProgressContext prog_ctx;
   MockSnapshotCreateRequest *req = new MockSnapshotCreateRequest(
     mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(),
-    "snap1", 0, 0, false, prog_ctx);
+    "snap1", 0, false, prog_ctx);
   {
     std::shared_lock owner_locker{mock_image_ctx.owner_lock};
     req->send();
@@ -353,7 +354,7 @@ TEST_F(TestMockOperationSnapshotCreateRequest, ReleaseSnapIdError) {
   librbd::NoOpProgressContext prog_ctx;
   MockSnapshotCreateRequest *req = new MockSnapshotCreateRequest(
     mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(),
-    "snap1", 0, 0, false, prog_ctx);
+    "snap1", 0, false, prog_ctx);
   {
     std::shared_lock owner_locker{mock_image_ctx.owner_lock};
     req->send();
@@ -393,7 +394,7 @@ TEST_F(TestMockOperationSnapshotCreateRequest, SkipObjectMap) {
   librbd::NoOpProgressContext prog_ctx;
   MockSnapshotCreateRequest *req = new MockSnapshotCreateRequest(
     mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(),
-    "snap1", 0, 0, true, prog_ctx);
+    "snap1", 0, true, prog_ctx);
   {
     std::shared_lock owner_locker{mock_image_ctx.owner_lock};
     req->send();
@@ -440,7 +441,7 @@ TEST_F(TestMockOperationSnapshotCreateRequest, SetImageState) {
     mock_image_ctx, &cond_ctx,
     cls::rbd::MirrorSnapshotNamespace{
       cls::rbd::MIRROR_SNAPSHOT_STATE_PRIMARY, {}, "", CEPH_NOSNAP},
-    "snap1", 0, 0, false, prog_ctx);
+    "snap1", 0, false, prog_ctx);
   {
     std::shared_lock owner_locker{mock_image_ctx.owner_lock};
     req->send();