update source to Ceph Pacific 16.2.2

[ceph.git] / ceph / src / test / librbd / test_DeepCopy.cc

diff --git a/ceph/src/test/librbd/test_DeepCopy.cc b/ceph/src/test/librbd/test_DeepCopy.cc
index 06498a506ecfba5d753f70d0ad2f5a9c1afb3ac2..1a512aa292c21eb3cead58529fe9c4a7399697cd 100644 (file)
--- a/ceph/src/test/librbd/test_DeepCopy.cc
+++ b/ceph/src/test/librbd/test_DeepCopy.cc
@@ -4,15 +4,17 @@
 #include "test/librbd/test_fixture.h"
 #include "test/librbd/test_support.h"
 #include "librbd/Operations.h"
+#include "librbd/api/Io.h"
 #include "librbd/api/Image.h"
 #include "librbd/api/Snapshot.h"
 #include "librbd/internal.h"
-#include "librbd/io/ImageRequestWQ.h"
 #include "librbd/io/ReadResult.h"
 
 void register_test_deep_copy() {
 }
 
+namespace librbd {
+
 struct TestDeepCopy : public TestFixture {
   void SetUp() override {
     TestFixture::SetUp();
@@ -21,7 +23,7 @@ struct TestDeepCopy : public TestFixture {
     int order = 22;
     uint64_t size = (1 << order) * 20;
     uint64_t features = 0;
-    bool old_format = !get_features(&features);
+    bool old_format = !::get_features(&features);
     EXPECT_EQ(0, create_image_full_pp(m_rbd, m_ioctx, image_name, size,
                                       features, old_format, &order));
     ASSERT_EQ(0, open_image(image_name, &m_src_ictx));
@@ -49,7 +51,7 @@ struct TestDeepCopy : public TestFixture {
   void deep_copy() {
     std::string dst_name = get_temp_image_name();
     librbd::NoOpProgressContext no_op;
-    EXPECT_EQ(0, m_src_ictx->io_work_queue->flush());
+    EXPECT_EQ(0, api::Io<>::flush(*m_src_ictx));
     EXPECT_EQ(0, librbd::api::Image<>::deep_copy(m_src_ictx, m_src_ictx->md_ctx,
                                                  dst_name.c_str(), m_opts,
                                                  no_op));
@@ -104,15 +106,17 @@ struct TestDeepCopy : public TestFixture {
         bufferlist src_bl;
         src_bl.push_back(src_ptr);
         librbd::io::ReadResult src_result{&src_bl};
-        EXPECT_EQ(read_size, m_src_ictx->io_work_queue->read(
-                    offset, read_size, librbd::io::ReadResult{src_result}, 0));
+        EXPECT_EQ(read_size, api::Io<>::read(
+                    *m_src_ictx, offset, read_size,
+                    librbd::io::ReadResult{src_result}, 0));
 
         bufferptr dst_ptr(read_size);
         bufferlist dst_bl;
         dst_bl.push_back(dst_ptr);
         librbd::io::ReadResult dst_result{&dst_bl};
-        EXPECT_EQ(read_size, m_dst_ictx->io_work_queue->read(
-                    offset, read_size, librbd::io::ReadResult{dst_result}, 0));
+        EXPECT_EQ(read_size, api::Io<>::read(
+                    *m_dst_ictx, offset, read_size,
+                    librbd::io::ReadResult{dst_result}, 0));
 
         if (!src_bl.contents_equal(dst_bl)) {
           std::cout << "snap: " << (src_snap_name ? src_snap_name : "null")
@@ -131,68 +135,66 @@ struct TestDeepCopy : public TestFixture {
     bufferlist bl;
     bl.append(std::string(((1 << m_src_ictx->order) * 2) + 1, '1'));
     ASSERT_EQ(static_cast<ssize_t>(bl.length()),
-              m_src_ictx->io_work_queue->write(0 * bl.length(), bl.length(),
-                                               bufferlist{bl}, 0));
+              api::Io<>::write(*m_src_ictx, 0 * bl.length(), bl.length(),
+                               bufferlist{bl}, 0));
     ASSERT_EQ(static_cast<ssize_t>(bl.length()),
-              m_src_ictx->io_work_queue->write(2 * bl.length(), bl.length(),
-                                               bufferlist{bl}, 0));
+              api::Io<>::write(*m_src_ictx, 2 * bl.length(), bl.length(),
+                               bufferlist{bl}, 0));
   }
 
   void test_snaps() {
     bufferlist bl;
     bl.append(std::string(((1 << m_src_ictx->order) * 2) + 1, '1'));
     ASSERT_EQ(static_cast<ssize_t>(bl.length()),
-              m_src_ictx->io_work_queue->write(0 * bl.length(), bl.length(),
-                                               bufferlist{bl}, 0));
-    ASSERT_EQ(0, m_src_ictx->io_work_queue->flush());
+              api::Io<>::write(*m_src_ictx, 0 * bl.length(), bl.length(),
+                               bufferlist{bl}, 0));
+    ASSERT_EQ(0, api::Io<>::flush(*m_src_ictx));
 
     ASSERT_EQ(0, snap_create(*m_src_ictx, "snap1"));
 
     ASSERT_EQ(static_cast<ssize_t>(bl.length()),
-              m_src_ictx->io_work_queue->write(1 * bl.length(), bl.length(),
-                                               bufferlist{bl}, 0));
+              api::Io<>::write(*m_src_ictx, 1 * bl.length(), bl.length(),
+                               bufferlist{bl}, 0));
     bufferlist bl1;
     bl1.append(std::string(1000, 'X'));
     ASSERT_EQ(static_cast<ssize_t>(bl1.length()),
-              m_src_ictx->io_work_queue->write(0 * bl.length(), bl1.length(),
-                                               bufferlist{bl1}, 0));
+              api::Io<>::write(*m_src_ictx, 0 * bl.length(), bl1.length(),
+                               bufferlist{bl1}, 0));
     ASSERT_EQ(static_cast<ssize_t>(bl1.length()),
-              m_src_ictx->io_work_queue->discard(bl1.length() + 10,
-                                                 bl1.length(), false));
+              api::Io<>::discard(*m_src_ictx, bl1.length() + 10,
+                                 bl1.length(), false));
 
-    ASSERT_EQ(0, m_src_ictx->io_work_queue->flush());
+    ASSERT_EQ(0, api::Io<>::flush(*m_src_ictx));
 
     ASSERT_EQ(0, snap_create(*m_src_ictx, "snap2"));
     ASSERT_EQ(static_cast<ssize_t>(bl1.length()),
-              m_src_ictx->io_work_queue->write(1 * bl.length(), bl1.length(),
-                                               bufferlist{bl1}, 0));
+              api::Io<>::write(*m_src_ictx, 1 * bl.length(), bl1.length(),
+                               bufferlist{bl1}, 0));
     ASSERT_EQ(static_cast<ssize_t>(bl1.length()),
-              m_src_ictx->io_work_queue->discard(2 * bl1.length() + 10,
-                                                 bl1.length(), false));
+              api::Io<>::discard(*m_src_ictx, 2 * bl1.length() + 10,
+                                 bl1.length(), false));
   }
 
   void test_snap_discard() {
     bufferlist bl;
     bl.append(std::string(100, '1'));
     ASSERT_EQ(static_cast<ssize_t>(bl.length()),
-              m_src_ictx->io_work_queue->write(0, bl.length(), bufferlist{bl},
-                                               0));
-    ASSERT_EQ(0, m_src_ictx->io_work_queue->flush());
+              api::Io<>::write(*m_src_ictx, 0, bl.length(), bufferlist{bl}, 0));
+    ASSERT_EQ(0, api::Io<>::flush(*m_src_ictx));
 
     ASSERT_EQ(0, snap_create(*m_src_ictx, "snap"));
 
     size_t len = (1 << m_src_ictx->order) * 2;
     ASSERT_EQ(static_cast<ssize_t>(len),
-              m_src_ictx->io_work_queue->discard(0, len, false));
+              api::Io<>::discard(*m_src_ictx, 0, len, false));
   }
 
   void test_clone_discard() {
     bufferlist bl;
     bl.append(std::string(100, '1'));
     ASSERT_EQ(static_cast<ssize_t>(bl.length()),
-              m_src_ictx->io_work_queue->write(0, bl.length(), bufferlist{bl},
-                                               0));
-    ASSERT_EQ(0, m_src_ictx->io_work_queue->flush());
+              api::Io<>::write(*m_src_ictx, 0, bl.length(), bufferlist{bl}, 0));
+    ASSERT_EQ(0, api::Io<>::flush(*m_src_ictx));
 
     ASSERT_EQ(0, snap_create(*m_src_ictx, "snap"));
     ASSERT_EQ(0, snap_protect(*m_src_ictx, "snap"));
@@ -209,16 +211,15 @@ struct TestDeepCopy : public TestFixture {
 
     size_t len = (1 << m_src_ictx->order) * 2;
     ASSERT_EQ(static_cast<ssize_t>(len),
-              m_src_ictx->io_work_queue->discard(0, len, false));
+              api::Io<>::discard(*m_src_ictx, 0, len, false));
   }
 
   void test_clone_shrink() {
     bufferlist bl;
     bl.append(std::string(100, '1'));
     ASSERT_EQ(static_cast<ssize_t>(bl.length()),
-              m_src_ictx->io_work_queue->write(0, bl.length(), bufferlist{bl},
-                                               0));
-    ASSERT_EQ(0, m_src_ictx->io_work_queue->flush());
+              api::Io<>::write(*m_src_ictx, 0, bl.length(), bufferlist{bl}, 0));
+    ASSERT_EQ(0, api::Io<>::flush(*m_src_ictx));
 
     ASSERT_EQ(0, snap_create(*m_src_ictx, "snap"));
     ASSERT_EQ(0, snap_protect(*m_src_ictx, "snap"));
@@ -242,9 +243,8 @@ struct TestDeepCopy : public TestFixture {
     bufferlist bl;
     bl.append(std::string(100, '1'));
     ASSERT_EQ(static_cast<ssize_t>(bl.length()),
-              m_src_ictx->io_work_queue->write(0, bl.length(), bufferlist{bl},
-                                               0));
-    ASSERT_EQ(0, m_src_ictx->io_work_queue->flush());
+              api::Io<>::write(*m_src_ictx, 0, bl.length(), bufferlist{bl}, 0));
+    ASSERT_EQ(0, api::Io<>::flush(*m_src_ictx));
 
     ASSERT_EQ(0, snap_create(*m_src_ictx, "snap"));
     ASSERT_EQ(0, snap_protect(*m_src_ictx, "snap"));
@@ -269,9 +269,9 @@ struct TestDeepCopy : public TestFixture {
     bufferlist bl;
     bl.append(std::string(100, '1'));
     ASSERT_EQ(static_cast<ssize_t>(bl.length()),
-              m_src_ictx->io_work_queue->write(object_size, bl.length(),
-                                               bufferlist{bl}, 0));
-    ASSERT_EQ(0, m_src_ictx->io_work_queue->flush());
+              api::Io<>::write(*m_src_ictx, object_size, bl.length(),
+                               bufferlist{bl}, 0));
+    ASSERT_EQ(0, api::Io<>::flush(*m_src_ictx));
 
     ASSERT_EQ(0, snap_create(*m_src_ictx, "snap"));
     ASSERT_EQ(0, snap_protect(*m_src_ictx, "snap"));
@@ -289,9 +289,8 @@ struct TestDeepCopy : public TestFixture {
     ASSERT_EQ(0, snap_create(*m_src_ictx, "snap1"));
 
     ASSERT_EQ(static_cast<ssize_t>(bl.length()),
-              m_src_ictx->io_work_queue->discard(object_size, bl.length(),
-                                                 false));
-    ASSERT_EQ(0, m_src_ictx->io_work_queue->flush());
+              api::Io<>::discard(*m_src_ictx, object_size, bl.length(), false));
+    ASSERT_EQ(0, api::Io<>::flush(*m_src_ictx));
 
     ASSERT_EQ(0, snap_create(*m_src_ictx, "snap2"));
 
@@ -307,12 +306,12 @@ struct TestDeepCopy : public TestFixture {
     bufferlist bl;
     bl.append(std::string(((1 << m_src_ictx->order) * 2) + 1, '1'));
     ASSERT_EQ(static_cast<ssize_t>(bl.length()),
-              m_src_ictx->io_work_queue->write(0 * bl.length(), bl.length(),
-                                               bufferlist{bl}, 0));
+              api::Io<>::write(*m_src_ictx, 0 * bl.length(), bl.length(),
+                               bufferlist{bl}, 0));
     ASSERT_EQ(static_cast<ssize_t>(bl.length()),
-              m_src_ictx->io_work_queue->write(2 * bl.length(), bl.length(),
-                                               bufferlist{bl}, 0));
-    ASSERT_EQ(0, m_src_ictx->io_work_queue->flush());
+              api::Io<>::write(*m_src_ictx, 2 * bl.length(), bl.length(),
+                               bufferlist{bl}, 0));
+    ASSERT_EQ(0, api::Io<>::flush(*m_src_ictx));
 
     ASSERT_EQ(0, snap_create(*m_src_ictx, "snap"));
     ASSERT_EQ(0, snap_protect(*m_src_ictx, "snap"));
@@ -330,12 +329,12 @@ struct TestDeepCopy : public TestFixture {
     bufferlist bl1;
     bl1.append(std::string(1000, 'X'));
     ASSERT_EQ(static_cast<ssize_t>(bl1.length()),
-              m_src_ictx->io_work_queue->write(0 * bl.length(), bl1.length(),
-                                               bufferlist{bl1}, 0));
+              api::Io<>::write(*m_src_ictx, 0 * bl.length(), bl1.length(),
+                               bufferlist{bl1}, 0));
     ASSERT_EQ(static_cast<ssize_t>(bl1.length()),
-              m_src_ictx->io_work_queue->discard(bl1.length() + 10,
-                                                 bl1.length(), false));
-    ASSERT_EQ(0, m_src_ictx->io_work_queue->flush());
+              api::Io<>::discard(*m_src_ictx, bl1.length() + 10,
+                                 bl1.length(), false));
+    ASSERT_EQ(0, api::Io<>::flush(*m_src_ictx));
 
     ASSERT_EQ(0, snap_create(*m_src_ictx, "snap"));
     ASSERT_EQ(0, snap_protect(*m_src_ictx, "snap"));
@@ -348,11 +347,11 @@ struct TestDeepCopy : public TestFixture {
     ASSERT_EQ(0, open_image(clone_name, &m_src_ictx));
 
     ASSERT_EQ(static_cast<ssize_t>(bl1.length()),
-              m_src_ictx->io_work_queue->write(1 * bl.length(), bl1.length(),
-                                               bufferlist{bl1}, 0));
+              api::Io<>::write(*m_src_ictx, 1 * bl.length(), bl1.length(),
+                               bufferlist{bl1}, 0));
     ASSERT_EQ(static_cast<ssize_t>(bl1.length()),
-              m_src_ictx->io_work_queue->discard(2 * bl1.length() + 10,
-                                                 bl1.length(), false));
+              api::Io<>::discard(*m_src_ictx, 2 * bl1.length() + 10,
+                                 bl1.length(), false));
   }
 
   void test_stress() {
@@ -387,18 +386,18 @@ struct TestDeepCopy : public TestFixture {
         std::cout << "write: " << static_cast<char>('A' + i) << " " << off
                   << "~" << len << std::endl;
         ASSERT_EQ(static_cast<ssize_t>(bl.length()),
-                  m_src_ictx->io_work_queue->write(off, bl.length(),
-                                                   bufferlist{bl}, 0));
+                  api::Io<>::write(*m_src_ictx, off, bl.length(),
+                                   bufferlist{bl}, 0));
         len = rand() % ((1 << m_src_ictx->order) * 2);
         ASSERT_GT(size, len);
         off = std::min(static_cast<uint64_t>(rand() % size),
                        static_cast<uint64_t>(size - len));
         std::cout << "discard: " << off << "~" << len << std::endl;
         ASSERT_EQ(static_cast<ssize_t>(len),
-                  m_src_ictx->io_work_queue->discard(off, len, false));
+                  api::Io<>::discard(*m_src_ictx, off, len, false));
       }
 
-      ASSERT_EQ(0, m_src_ictx->io_work_queue->flush());
+      ASSERT_EQ(0, api::Io<>::flush(*m_src_ictx));
 
       std::string snap_name = "snap" + stringify(i);
       std::cout << "snap: " << snap_name << std::endl;
@@ -756,3 +755,5 @@ TEST_F(TestDeepCopy, Stress_StrippingSmallerDstObjSize)
 
   test_stress();
 }
+
+} // namespace librbd