update ceph source to reef 18.1.2

[ceph.git] / ceph / src / test / librbd / crypto / test_mock_CryptoObjectDispatch.cc

diff --git a/ceph/src/test/librbd/crypto/test_mock_CryptoObjectDispatch.cc b/ceph/src/test/librbd/crypto/test_mock_CryptoObjectDispatch.cc
index 04b6b8962b012dbb04d9a2e59a768abab420f19d..bfd29261628bdc25a317c0ed09d6602d93b938c7 100644 (file)
--- a/ceph/src/test/librbd/crypto/test_mock_CryptoObjectDispatch.cc
+++ b/ceph/src/test/librbd/crypto/test_mock_CryptoObjectDispatch.cc
@@ -39,9 +39,9 @@ struct CopyupRequest<librbd::MockImageCtx> {
             const Extents&));
 
     static CopyupRequest* s_instance;
-    static CopyupRequest* create(librbd::MockImageCtx *ictx,
-                                 uint64_t objectno, Extents &&image_extents,
-                                 const ZTracer::Trace &parent_trace) {
+    static CopyupRequest* create(librbd::MockImageCtx* ictx, uint64_t objectno,
+                                 Extents&& image_extents, ImageArea area,
+                                 const ZTracer::Trace& parent_trace) {
       return s_instance;
     }
 
@@ -55,12 +55,6 @@ CopyupRequest<librbd::MockImageCtx>* CopyupRequest<
 
 namespace util {
 
-template <> uint64_t get_file_offset(
-        MockImageCtx *image_ctx, uint64_t object_no, uint64_t offset) {
-  return Striper::get_file_offset(image_ctx->cct, &image_ctx->layout,
-                                  object_no, offset);
-}
-
 namespace {
 
 struct Mock {
@@ -98,6 +92,13 @@ template <> void read_parent(
 namespace librbd {
 namespace crypto {
 
+template <>
+uint64_t get_file_offset(MockImageCtx *image_ctx, uint64_t object_no,
+                         uint64_t offset) {
+  return Striper::get_file_offset(image_ctx->cct, &image_ctx->layout,
+                                  object_no, offset);
+}
+
 using ::testing::_;
 using ::testing::ElementsAre;
 using ::testing::Invoke;
@@ -113,7 +114,7 @@ struct TestMockCryptoCryptoObjectDispatch : public TestMockFixture {
   typedef io::CopyupRequest<librbd::MockImageCtx> MockCopyupRequest;
   typedef io::util::Mock MockUtils;
 
-  MockCryptoInterface* crypto;
+  MockCryptoInterface crypto;
   MockImageCtx* mock_image_ctx;
   MockCryptoObjectDispatch* mock_crypto_object_dispatch;
 
@@ -134,10 +135,9 @@ struct TestMockCryptoCryptoObjectDispatch : public TestMockFixture {
 
     librbd::ImageCtx *ictx;
     ASSERT_EQ(0, open_image(m_image_name, &ictx));
-    crypto = new MockCryptoInterface();
     mock_image_ctx = new MockImageCtx(*ictx);
     mock_crypto_object_dispatch = new MockCryptoObjectDispatch(
-            mock_image_ctx, crypto);
+            mock_image_ctx, &crypto);
     data.append(std::string(4096, '1'));
   }
 
@@ -225,10 +225,9 @@ struct TestMockCryptoCryptoObjectDispatch : public TestMockFixture {
             mock_image_ctx->layout.object_size));
   }
 
-  void expect_remap_extents(uint64_t offset, uint64_t length) {
-    EXPECT_CALL(*mock_image_ctx->io_image_dispatcher, remap_extents(
-            ElementsAre(Pair(offset, length)),
-            io::IMAGE_EXTENTS_MAP_TYPE_PHYSICAL_TO_LOGICAL));
+  void expect_remap_to_logical(uint64_t offset, uint64_t length) {
+    EXPECT_CALL(*mock_image_ctx->io_image_dispatcher, remap_to_logical(
+            ElementsAre(Pair(offset, length))));
   }
 
   void expect_get_parent_overlap(uint64_t overlap) {
@@ -240,7 +239,7 @@ struct TestMockCryptoCryptoObjectDispatch : public TestMockFixture {
   }
 
   void expect_prune_parent_extents(uint64_t object_overlap) {
-    EXPECT_CALL(*mock_image_ctx, prune_parent_extents(_, _))
+    EXPECT_CALL(*mock_image_ctx, prune_parent_extents(_, _, _, _))
             .WillOnce(Return(object_overlap));
   }
 
@@ -258,11 +257,11 @@ struct TestMockCryptoCryptoObjectDispatch : public TestMockFixture {
   }
 
   void expect_encrypt(int count = 1) {
-    EXPECT_CALL(*crypto, encrypt(_, _)).Times(count);
+    EXPECT_CALL(crypto, encrypt(_, _)).Times(count);
   }
 
   void expect_decrypt(int count = 1) {
-    EXPECT_CALL(*crypto, decrypt(_, _)).Times(count);
+    EXPECT_CALL(crypto, decrypt(_, _)).Times(count);
   }
 };
 
@@ -277,7 +276,7 @@ TEST_F(TestMockCryptoCryptoObjectDispatch, Flush) {
 TEST_F(TestMockCryptoCryptoObjectDispatch, Discard) {
   expect_object_write_same();
   ASSERT_TRUE(mock_crypto_object_dispatch->discard(
-          0, 0, 4096, mock_image_ctx->get_data_io_context(), 0, {},
+          11, 0, 4096, mock_image_ctx->get_data_io_context(), 0, {},
           &object_dispatch_flags, nullptr, &dispatch_result, &on_finish,
           on_dispatched));
   ASSERT_EQ(dispatch_result, io::DISPATCH_RESULT_COMPLETE);
@@ -291,7 +290,7 @@ TEST_F(TestMockCryptoCryptoObjectDispatch, AlignedReadFail) {
   io::ReadExtents extents = {{0, 4096}};
   expect_object_read(&extents);
   ASSERT_TRUE(mock_crypto_object_dispatch->read(
-      0, &extents, mock_image_ctx->get_data_io_context(), 0, 0, {},
+      11, &extents, mock_image_ctx->get_data_io_context(), 0, 0, {},
       nullptr, &object_dispatch_flags, &dispatch_result,
       &on_finish, on_dispatched));
   ASSERT_EQ(dispatch_result, io::DISPATCH_RESULT_COMPLETE);
@@ -310,7 +309,7 @@ TEST_F(TestMockCryptoCryptoObjectDispatch, AlignedRead) {
   extents[1].bl.append(std::string(4096, '0'));
   expect_object_read(&extents);
   ASSERT_TRUE(mock_crypto_object_dispatch->read(
-          0, &extents, mock_image_ctx->get_data_io_context(), 0, 0, {},
+          11, &extents, mock_image_ctx->get_data_io_context(), 0, 0, {},
           nullptr, &object_dispatch_flags, &dispatch_result,
           &on_finish, on_dispatched));
   ASSERT_EQ(dispatch_result, io::DISPATCH_RESULT_COMPLETE);
@@ -334,9 +333,9 @@ TEST_F(TestMockCryptoCryptoObjectDispatch, AlignedRead) {
 TEST_F(TestMockCryptoCryptoObjectDispatch, ReadFromParent) {
   io::ReadExtents extents = {{0, 4096}, {8192, 4096}};
   expect_object_read(&extents);
-  expect_read_parent(mock_utils, 0, &extents, CEPH_NOSNAP, 8192);
+  expect_read_parent(mock_utils, 11, &extents, CEPH_NOSNAP, 8192);
   ASSERT_TRUE(mock_crypto_object_dispatch->read(
-          0, &extents, mock_image_ctx->get_data_io_context(), 0, 0, {},
+          11, &extents, mock_image_ctx->get_data_io_context(), 0, 0, {},
           nullptr, &object_dispatch_flags, &dispatch_result,
           &on_finish, on_dispatched));
   ASSERT_EQ(dispatch_result, io::DISPATCH_RESULT_COMPLETE);
@@ -352,7 +351,7 @@ TEST_F(TestMockCryptoCryptoObjectDispatch, ReadFromParentDisabled) {
   io::ReadExtents extents = {{0, 4096}, {8192, 4096}};
   expect_object_read(&extents);
   ASSERT_TRUE(mock_crypto_object_dispatch->read(
-          0, &extents, mock_image_ctx->get_data_io_context(), 0,
+          11, &extents, mock_image_ctx->get_data_io_context(), 0,
           io::READ_FLAG_DISABLE_READ_FROM_PARENT, {},
           nullptr, &object_dispatch_flags, &dispatch_result,
           &on_finish, on_dispatched));
@@ -381,7 +380,7 @@ TEST_F(TestMockCryptoCryptoObjectDispatch, UnalignedRead) {
 
   expect_object_read(&aligned_extents);
   ASSERT_TRUE(mock_crypto_object_dispatch->read(
-          0, &extents, mock_image_ctx->get_data_io_context(), 0, 0, {},
+          11, &extents, mock_image_ctx->get_data_io_context(), 0, 0, {},
           nullptr, &object_dispatch_flags, &dispatch_result,
           &on_finish, on_dispatched));
   ASSERT_EQ(dispatch_result, io::DISPATCH_RESULT_COMPLETE);
@@ -405,7 +404,7 @@ TEST_F(TestMockCryptoCryptoObjectDispatch, UnalignedRead) {
 TEST_F(TestMockCryptoCryptoObjectDispatch, AlignedWrite) {
   expect_encrypt();
   ASSERT_TRUE(mock_crypto_object_dispatch->write(
-        0, 0, std::move(data), mock_image_ctx->get_data_io_context(), 0, 0,
+        11, 0, std::move(data), mock_image_ctx->get_data_io_context(), 0, 0,
         std::nullopt, {}, nullptr, nullptr, &dispatch_result, &on_finish,
         on_dispatched));
   ASSERT_EQ(dispatch_result, io::DISPATCH_RESULT_CONTINUE);
@@ -423,7 +422,7 @@ TEST_F(TestMockCryptoCryptoObjectDispatch, UnalignedWrite) {
   extents[1].bl.append(std::string(4096, '3'));
   expect_object_read(&extents, version);
   ASSERT_TRUE(mock_crypto_object_dispatch->write(
-          0, 1, std::move(write_data), mock_image_ctx->get_data_io_context(),
+          11, 1, std::move(write_data), mock_image_ctx->get_data_io_context(),
           0, 0, std::nullopt, {}, nullptr, nullptr, &dispatch_result,
           &on_finish, on_dispatched));
   ASSERT_EQ(dispatch_result, io::DISPATCH_RESULT_COMPLETE);
@@ -444,7 +443,7 @@ TEST_F(TestMockCryptoCryptoObjectDispatch, UnalignedWriteWithNoObject) {
   io::ReadExtents extents = {{0, 4096}, {8192, 4096}};
   expect_object_read(&extents);
   ASSERT_TRUE(mock_crypto_object_dispatch->write(
-          0, 1, std::move(write_data), mock_image_ctx->get_data_io_context(),
+          11, 1, std::move(write_data), mock_image_ctx->get_data_io_context(),
           0, 0, std::nullopt, {}, nullptr, nullptr, &dispatch_result,
           &on_finish, on_dispatched));
   ASSERT_EQ(dispatch_result, io::DISPATCH_RESULT_COMPLETE);
@@ -468,7 +467,7 @@ TEST_F(TestMockCryptoCryptoObjectDispatch, UnalignedWriteFailCreate) {
   io::ReadExtents extents = {{0, 4096}, {8192, 4096}};
   expect_object_read(&extents);
   ASSERT_TRUE(mock_crypto_object_dispatch->write(
-          0, 1, std::move(write_data), mock_image_ctx->get_data_io_context(),
+          11, 1, std::move(write_data), mock_image_ctx->get_data_io_context(),
           0, 0, std::nullopt, {}, nullptr, nullptr, &dispatch_result,
           &on_finish, on_dispatched));
   ASSERT_EQ(dispatch_result, io::DISPATCH_RESULT_COMPLETE);
@@ -510,19 +509,20 @@ TEST_F(TestMockCryptoCryptoObjectDispatch, UnalignedWriteCopyup) {
   io::ReadExtents extents = {{0, 4096}, {8192, 4096}};
   expect_object_read(&extents);
   ASSERT_TRUE(mock_crypto_object_dispatch->write(
-          0, 1, std::move(write_data), mock_image_ctx->get_data_io_context(),
+          11, 1, std::move(write_data), mock_image_ctx->get_data_io_context(),
           0, 0, std::nullopt, {}, nullptr, nullptr, &dispatch_result,
           &on_finish, on_dispatched));
   ASSERT_EQ(dispatch_result, io::DISPATCH_RESULT_COMPLETE);
   ASSERT_EQ(on_finish, &finished_cond);
 
   expect_get_object_size();
-  expect_get_parent_overlap(mock_image_ctx->layout.object_size);
-  expect_remap_extents(0, mock_image_ctx->layout.object_size);
+  expect_get_parent_overlap(100 << 20);
+  expect_remap_to_logical(11 * mock_image_ctx->layout.object_size,
+                          mock_image_ctx->layout.object_size);
   expect_prune_parent_extents(mock_image_ctx->layout.object_size);
   EXPECT_CALL(mock_exclusive_lock, is_lock_owner()).WillRepeatedly(
           Return(true));
-  EXPECT_CALL(*mock_image_ctx->object_map, object_may_exist(0)).WillOnce(
+  EXPECT_CALL(*mock_image_ctx->object_map, object_may_exist(11)).WillOnce(
           Return(false));
   MockAbstractObjectWriteRequest *write_request = nullptr;
   expect_copyup(&write_request, 0);
@@ -555,19 +555,20 @@ TEST_F(TestMockCryptoCryptoObjectDispatch, UnalignedWriteEmptyCopyup) {
   io::ReadExtents extents = {{0, 4096}, {8192, 4096}};
   expect_object_read(&extents);
   ASSERT_TRUE(mock_crypto_object_dispatch->write(
-          0, 1, std::move(write_data), mock_image_ctx->get_data_io_context(),
+          11, 1, std::move(write_data), mock_image_ctx->get_data_io_context(),
           0, 0, std::nullopt, {}, nullptr, nullptr, &dispatch_result,
           &on_finish, on_dispatched));
   ASSERT_EQ(dispatch_result, io::DISPATCH_RESULT_COMPLETE);
   ASSERT_EQ(on_finish, &finished_cond);
 
   expect_get_object_size();
-  expect_get_parent_overlap(mock_image_ctx->layout.object_size);
-  expect_remap_extents(0, mock_image_ctx->layout.object_size);
+  expect_get_parent_overlap(100 << 20);
+  expect_remap_to_logical(11 * mock_image_ctx->layout.object_size,
+                          mock_image_ctx->layout.object_size);
   expect_prune_parent_extents(mock_image_ctx->layout.object_size);
   EXPECT_CALL(mock_exclusive_lock, is_lock_owner()).WillRepeatedly(
           Return(true));
-  EXPECT_CALL(*mock_image_ctx->object_map, object_may_exist(0)).WillOnce(
+  EXPECT_CALL(*mock_image_ctx->object_map, object_may_exist(11)).WillOnce(
           Return(false));
   MockAbstractObjectWriteRequest *write_request = nullptr;
   expect_copyup(&write_request, 0);
@@ -597,7 +598,7 @@ TEST_F(TestMockCryptoCryptoObjectDispatch, UnalignedWriteFailVersionCheck) {
   extents[1].bl.append(std::string(4096, '3'));
   expect_object_read(&extents, version);
   ASSERT_TRUE(mock_crypto_object_dispatch->write(
-          0, 1, std::move(write_data), mock_image_ctx->get_data_io_context(),
+          11, 1, std::move(write_data), mock_image_ctx->get_data_io_context(),
           0, 0, std::nullopt, {}, nullptr, nullptr, &dispatch_result,
           &on_finish, on_dispatched));
   ASSERT_EQ(dispatch_result, io::DISPATCH_RESULT_COMPLETE);
@@ -633,7 +634,7 @@ TEST_F(TestMockCryptoCryptoObjectDispatch, UnalignedWriteWithAssertVersion) {
   extents[1].bl.append(std::string(4096, '3'));
   expect_object_read(&extents, version);
   ASSERT_TRUE(mock_crypto_object_dispatch->write(
-          0, 1, std::move(write_data), mock_image_ctx->get_data_io_context(),
+          11, 1, std::move(write_data), mock_image_ctx->get_data_io_context(),
           0, 0, std::make_optional(assert_version), {}, nullptr, nullptr,
           &dispatch_result, &on_finish, on_dispatched));
   ASSERT_EQ(dispatch_result, io::DISPATCH_RESULT_COMPLETE);
@@ -651,7 +652,7 @@ TEST_F(TestMockCryptoCryptoObjectDispatch, UnalignedWriteWithExclusiveCreate) {
   extents[1].bl.append(std::string(4096, '3'));
   expect_object_read(&extents);
   ASSERT_TRUE(mock_crypto_object_dispatch->write(
-          0, 1, std::move(write_data), mock_image_ctx->get_data_io_context(),
+          11, 1, std::move(write_data), mock_image_ctx->get_data_io_context(),
           0, io::OBJECT_WRITE_FLAG_CREATE_EXCLUSIVE, std::nullopt, {}, nullptr,
           nullptr, &dispatch_result, &on_finish, on_dispatched));
   ASSERT_EQ(dispatch_result, io::DISPATCH_RESULT_COMPLETE);
@@ -674,7 +675,7 @@ TEST_F(TestMockCryptoCryptoObjectDispatch, CompareAndWrite) {
   expect_object_read(&extents, version);
 
   ASSERT_TRUE(mock_crypto_object_dispatch->compare_and_write(
-          0, 1, std::move(cmp_data), std::move(write_data),
+          11, 1, std::move(cmp_data), std::move(write_data),
           mock_image_ctx->get_data_io_context(), 0, {}, nullptr, nullptr,
           nullptr, &dispatch_result, &on_finish, on_dispatched));
   ASSERT_EQ(dispatch_result, io::DISPATCH_RESULT_COMPLETE);
@@ -703,7 +704,7 @@ TEST_F(TestMockCryptoCryptoObjectDispatch, CompareAndWriteFail) {
 
   uint64_t mismatch_offset;
   ASSERT_TRUE(mock_crypto_object_dispatch->compare_and_write(
-          0, 1, std::move(cmp_data), std::move(write_data),
+          11, 1, std::move(cmp_data), std::move(write_data),
           mock_image_ctx->get_data_io_context(), 0, {}, &mismatch_offset,
           nullptr, nullptr, &dispatch_result, &on_finish, on_dispatched));
   ASSERT_EQ(dispatch_result, io::DISPATCH_RESULT_COMPLETE);
@@ -720,7 +721,7 @@ TEST_F(TestMockCryptoCryptoObjectDispatch, WriteSame) {
   write_data.append(std::string("12"));
   expect_object_write(0, std::string("12121") , 0, std::nullopt);
   ASSERT_TRUE(mock_crypto_object_dispatch->write_same(
-          0, 0, 5, {{0, 5}}, std::move(write_data),
+          11, 0, 5, {{0, 5}}, std::move(write_data),
           mock_image_ctx->get_data_io_context(), 0, {}, nullptr, nullptr,
           &dispatch_result, &on_finish, on_dispatched));
   ASSERT_EQ(dispatch_result, io::DISPATCH_RESULT_COMPLETE);
@@ -752,14 +753,15 @@ TEST_F(TestMockCryptoCryptoObjectDispatch, PrepareCopyup) {
   expect_get_object_size();
   expect_encrypt(6);
   InSequence seq;
-  expect_remap_extents(0, 4096);
-  expect_remap_extents(4096, 4096);
-  expect_remap_extents(8192, 4096);
-  expect_remap_extents(0, 4096);
-  expect_remap_extents(4096, 8192);
-  expect_remap_extents(16384, 4096);
+  uint64_t base = 11 * mock_image_ctx->layout.object_size;
+  expect_remap_to_logical(base, 4096);
+  expect_remap_to_logical(base + 4096, 4096);
+  expect_remap_to_logical(base + 8192, 4096);
+  expect_remap_to_logical(base, 4096);
+  expect_remap_to_logical(base + 4096, 8192);
+  expect_remap_to_logical(base + 16384, 4096);
   ASSERT_EQ(0, mock_crypto_object_dispatch->prepare_copyup(
-          0, &snapshot_sparse_bufferlist));
+      11, &snapshot_sparse_bufferlist));
 
   ASSERT_EQ(2, snapshot_sparse_bufferlist.size());
 
@@ -794,5 +796,5 @@ TEST_F(TestMockCryptoCryptoObjectDispatch, PrepareCopyup) {
   ASSERT_EQ(++it, snap2_result.end());
 }
 
-} // namespace io
+} // namespace crypto
 } // namespace librbd