import ceph quincy 17.2.6

[ceph.git] / ceph / src / test / rgw / test_cls_fifo_legacy.cc

diff --git a/ceph/src/test/rgw/test_cls_fifo_legacy.cc b/ceph/src/test/rgw/test_cls_fifo_legacy.cc
index 26d9e9a9253e4e67f069481d75b3c8c49fac7ed0..ec5b35bda0900dcfe9639d4b181a70f661979cab 100644 (file)
--- a/ceph/src/test/rgw/test_cls_fifo_legacy.cc
+++ b/ceph/src/test/rgw/test_cls_fifo_legacy.cc
@@ -19,6 +19,7 @@
 #include "include/scope_guard.h"
 #include "include/types.h"
 #include "include/rados/librados.hpp"
+#include "common/ceph_context.h"
 
 #include "cls/fifo/cls_fifo_ops.h"
 #include "test/librados/test_cxx.h"
@@ -29,13 +30,19 @@
 
 #include "gtest/gtest.h"
 
+using namespace std::literals;
+using namespace std::string_literals;
+
 namespace R = librados;
 namespace cb = ceph::buffer;
 namespace fifo = rados::cls::fifo;
 namespace RCf = rgw::cls::fifo;
 
+auto cct = new CephContext(CEPH_ENTITY_TYPE_CLIENT);
+const DoutPrefix dp(cct, 1, "test legacy cls fifo: ");
+
 namespace {
-int fifo_create(R::IoCtx& ioctx,
+int fifo_create(const DoutPrefixProvider *dpp, R::IoCtx& ioctx,
                const std::string& oid,
                std::string_view id,
                optional_yield y,
@@ -48,7 +55,7 @@ int fifo_create(R::IoCtx& ioctx,
   R::ObjectWriteOperation op;
   RCf::create_meta(&op, id, objv, oid_prefix, exclusive, max_part_size,
                   max_entry_size);
-  return rgw_rados_operate(ioctx, oid, &op, y);
+  return rgw_rados_operate(dpp, ioctx, oid, &op, y);
 }
 }
 
@@ -74,54 +81,54 @@ using AioLegacyFIFO = LegacyFIFO;
 
 TEST_F(LegacyClsFIFO, TestCreate)
 {
-  auto r = fifo_create(ioctx, fifo_id, ""s, null_yield);
+  auto r = fifo_create(&dp, ioctx, fifo_id, ""s, null_yield);
   EXPECT_EQ(-EINVAL, r);
-  r = fifo_create(ioctx, fifo_id, fifo_id, null_yield, std::nullopt,
+  r = fifo_create(&dp, ioctx, fifo_id, fifo_id, null_yield, std::nullopt,
                  std::nullopt, false, 0);
   EXPECT_EQ(-EINVAL, r);
-  r = fifo_create(ioctx, fifo_id, {}, null_yield,
+  r = fifo_create(&dp, ioctx, fifo_id, {}, null_yield,
                  std::nullopt, std::nullopt,
                  false, RCf::default_max_part_size, 0);
   EXPECT_EQ(-EINVAL, r);
-  r = fifo_create(ioctx, fifo_id, fifo_id, null_yield);
+  r = fifo_create(&dp, ioctx, fifo_id, fifo_id, null_yield);
   EXPECT_EQ(0, r);
   std::uint64_t size;
   ioctx.stat(fifo_id, &size, nullptr);
   EXPECT_GT(size, 0);
   /* test idempotency */
-  r = fifo_create(ioctx, fifo_id, fifo_id, null_yield);
+  r = fifo_create(&dp, ioctx, fifo_id, fifo_id, null_yield);
   EXPECT_EQ(0, r);
-  r = fifo_create(ioctx, fifo_id, {}, null_yield, std::nullopt,
+  r = fifo_create(&dp, ioctx, fifo_id, {}, null_yield, std::nullopt,
                  std::nullopt, false);
   EXPECT_EQ(-EINVAL, r);
-  r = fifo_create(ioctx, fifo_id, {}, null_yield, std::nullopt,
+  r = fifo_create(&dp, ioctx, fifo_id, {}, null_yield, std::nullopt,
                  "myprefix"sv, false);
   EXPECT_EQ(-EINVAL, r);
-  r = fifo_create(ioctx, fifo_id, "foo"sv, null_yield,
+  r = fifo_create(&dp, ioctx, fifo_id, "foo"sv, null_yield,
                  std::nullopt, std::nullopt, false);
   EXPECT_EQ(-EEXIST, r);
 }
 
 TEST_F(LegacyClsFIFO, TestGetInfo)
 {
-  auto r = fifo_create(ioctx, fifo_id, fifo_id, null_yield);
+  auto r = fifo_create(&dp, ioctx, fifo_id, fifo_id, null_yield);
   fifo::info info;
   std::uint32_t part_header_size;
   std::uint32_t part_entry_overhead;
-  r = RCf::get_meta(ioctx, fifo_id, std::nullopt, &info, &part_header_size,
+  r = RCf::get_meta(&dp, ioctx, fifo_id, std::nullopt, &info, &part_header_size,
                    &part_entry_overhead, 0, null_yield);
   EXPECT_EQ(0, r);
   EXPECT_GT(part_header_size, 0);
   EXPECT_GT(part_entry_overhead, 0);
   EXPECT_FALSE(info.version.instance.empty());
 
-  r = RCf::get_meta(ioctx, fifo_id, info.version, &info, &part_header_size,
+  r = RCf::get_meta(&dp, ioctx, fifo_id, info.version, &info, &part_header_size,
                    &part_entry_overhead, 0, null_yield);
   EXPECT_EQ(0, r);
   fifo::objv objv;
   objv.instance = "foo";
   objv.ver = 12;
-  r = RCf::get_meta(ioctx, fifo_id, objv, &info, &part_header_size,
+  r = RCf::get_meta(&dp, ioctx, fifo_id, objv, &info, &part_header_size,
                    &part_entry_overhead, 0, null_yield);
   EXPECT_EQ(-ECANCELED, r);
 }
@@ -129,10 +136,10 @@ TEST_F(LegacyClsFIFO, TestGetInfo)
 TEST_F(LegacyFIFO, TestOpenDefault)
 {
   std::unique_ptr<RCf::FIFO> fifo;
-  auto r = RCf::FIFO::create(ioctx, fifo_id, &fifo, null_yield);
+  auto r = RCf::FIFO::create(&dp, ioctx, fifo_id, &fifo, null_yield);
   ASSERT_EQ(0, r);
   // force reading from backend
-  r = fifo->read_meta(null_yield);
+  r = fifo->read_meta(&dp, null_yield);
   EXPECT_EQ(0, r);
   auto info = fifo->meta();
   EXPECT_EQ(info.id, fifo_id);
@@ -149,12 +156,12 @@ TEST_F(LegacyFIFO, TestOpenParams)
 
   /* first successful create */
   std::unique_ptr<RCf::FIFO> f;
-  auto r = RCf::FIFO::create(ioctx, fifo_id, &f, null_yield, objv, oid_prefix,
+  auto r = RCf::FIFO::create(&dp, ioctx, fifo_id, &f, null_yield, objv, oid_prefix,
                             false, max_part_size, max_entry_size);
   ASSERT_EQ(0, r);
 
   /* force reading from backend */
-  r = f->read_meta(null_yield);
+  r = f->read_meta(&dp, null_yield);
   auto info = f->meta();
   EXPECT_EQ(info.id, fifo_id);
   EXPECT_EQ(info.params.max_part_size, max_part_size);
@@ -177,13 +184,13 @@ std::pair<T, std::string> decode_entry(const RCf::list_entry& entry)
 TEST_F(LegacyFIFO, TestPushListTrim)
 {
   std::unique_ptr<RCf::FIFO> f;
-  auto r = RCf::FIFO::create(ioctx, fifo_id, &f, null_yield);
+  auto r = RCf::FIFO::create(&dp, ioctx, fifo_id, &f, null_yield);
   ASSERT_EQ(0, r);
   static constexpr auto max_entries = 10u;
   for (uint32_t i = 0; i < max_entries; ++i) {
     cb::list bl;
     encode(i, bl);
-    r = f->push(bl, null_yield);
+    r = f->push(&dp, bl, null_yield);
     ASSERT_EQ(0, r);
   }
 
@@ -193,7 +200,7 @@ TEST_F(LegacyFIFO, TestPushListTrim)
   bool more = false;
   for (auto i = 0u; i < max_entries; ++i) {
 
-    r = f->list(1, marker, &result, &more, null_yield);
+    r = f->list(&dp, 1, marker, &result, &more, null_yield);
     ASSERT_EQ(0, r);
 
     bool expected_more = (i != (max_entries - 1));
@@ -210,7 +217,7 @@ TEST_F(LegacyFIFO, TestPushListTrim)
   /* get all entries at once */
   std::string markers[max_entries];
   std::uint32_t min_entry = 0;
-  r = f->list(max_entries * 10, std::nullopt, &result, &more, null_yield);
+  r = f->list(&dp, max_entries * 10, std::nullopt, &result, &more, null_yield);
   ASSERT_EQ(0, r);
 
   ASSERT_FALSE(more);
@@ -222,11 +229,11 @@ TEST_F(LegacyFIFO, TestPushListTrim)
   }
 
   /* trim one entry */
-  r = f->trim(markers[min_entry], false, null_yield);
+  r = f->trim(&dp, markers[min_entry], false, null_yield);
   ASSERT_EQ(0, r);
   ++min_entry;
 
-  r = f->list(max_entries * 10, std::nullopt, &result, &more, null_yield);
+  r = f->list(&dp, max_entries * 10, std::nullopt, &result, &more, null_yield);
   ASSERT_EQ(0, r);
   ASSERT_FALSE(more);
   ASSERT_EQ(max_entries - min_entry, result.size());
@@ -246,7 +253,7 @@ TEST_F(LegacyFIFO, TestPushTooBig)
   static constexpr auto max_entry_size = 128ull;
 
   std::unique_ptr<RCf::FIFO> f;
-  auto r = RCf::FIFO::create(ioctx, fifo_id, &f, null_yield, std::nullopt,
+  auto r = RCf::FIFO::create(&dp, ioctx, fifo_id, &f, null_yield, std::nullopt,
                             std::nullopt, false, max_part_size, max_entry_size);
   ASSERT_EQ(0, r);
 
@@ -256,7 +263,7 @@ TEST_F(LegacyFIFO, TestPushTooBig)
   cb::list bl;
   bl.append(buf, sizeof(buf));
 
-  r = f->push(bl, null_yield);
+  r = f->push(&dp, bl, null_yield);
   EXPECT_EQ(-E2BIG, r);
 }
 
@@ -266,7 +273,7 @@ TEST_F(LegacyFIFO, TestMultipleParts)
   static constexpr auto max_part_size = 2048ull;
   static constexpr auto max_entry_size = 128ull;
   std::unique_ptr<RCf::FIFO> f;
-  auto r = RCf::FIFO::create(ioctx, fifo_id, &f, null_yield, std::nullopt,
+  auto r = RCf::FIFO::create(&dp, ioctx, fifo_id, &f, null_yield, std::nullopt,
                             std::nullopt, false, max_part_size,
                             max_entry_size);
   ASSERT_EQ(0, r);
@@ -283,7 +290,7 @@ TEST_F(LegacyFIFO, TestMultipleParts)
     cb::list bl;
     *(int *)buf = i;
     bl.append(buf, sizeof(buf));
-    r = f->push(bl, null_yield);
+    r = f->push(&dp, bl, null_yield);
     ASSERT_EQ(0, r);
   }
 
@@ -295,7 +302,7 @@ TEST_F(LegacyFIFO, TestMultipleParts)
   /* list all at once */
   std::vector<RCf::list_entry> result;
   bool more = false;
-  r = f->list(max_entries, std::nullopt, &result, &more, null_yield);
+  r = f->list(&dp, max_entries, std::nullopt, &result, &more, null_yield);
   ASSERT_EQ(0, r);
   EXPECT_EQ(false, more);
   ASSERT_EQ(max_entries, result.size());
@@ -309,7 +316,7 @@ TEST_F(LegacyFIFO, TestMultipleParts)
   /* get entries one by one */
 
   for (auto i = 0u; i < max_entries; ++i) {
-    r = f->list(1, marker, &result, &more, null_yield);
+    r = f->list(&dp, 1, marker, &result, &more, null_yield);
     ASSERT_EQ(0, r);
     ASSERT_EQ(result.size(), 1);
     const bool expected_more = (i != (max_entries - 1));
@@ -328,14 +335,14 @@ TEST_F(LegacyFIFO, TestMultipleParts)
   marker.reset();
   for (auto i = 0u; i < max_entries; ++i) {
     /* read single entry */
-    r = f->list(1, marker, &result, &more, null_yield);
+    r = f->list(&dp, 1, marker, &result, &more, null_yield);
     ASSERT_EQ(0, r);
     ASSERT_EQ(result.size(), 1);
     const bool expected_more = (i != (max_entries - 1));
     ASSERT_EQ(expected_more, more);
 
     marker = result.front().marker;
-    r = f->trim(*marker, false, null_yield);
+    r = f->trim(&dp, *marker, false, null_yield);
     ASSERT_EQ(0, r);
 
     /* check tail */
@@ -343,7 +350,7 @@ TEST_F(LegacyFIFO, TestMultipleParts)
     ASSERT_EQ(info.tail_part_num, i / entries_per_part);
 
     /* try to read all again, see how many entries left */
-    r = f->list(max_entries, marker, &result, &more, null_yield);
+    r = f->list(&dp, max_entries, marker, &result, &more, null_yield);
     ASSERT_EQ(max_entries - i - 1, result.size());
     ASSERT_EQ(false, more);
   }
@@ -355,11 +362,11 @@ TEST_F(LegacyFIFO, TestMultipleParts)
   RCf::part_info partinfo;
   /* check old tails are removed */
   for (auto i = 0; i < info.tail_part_num; ++i) {
-    r = f->get_part_info(i, &partinfo, null_yield);
+    r = f->get_part_info(&dp, i, &partinfo, null_yield);
     ASSERT_EQ(-ENOENT, r);
   }
   /* check current tail exists */
-  r = f->get_part_info(info.tail_part_num, &partinfo, null_yield);
+  r = f->get_part_info(&dp, info.tail_part_num, &partinfo, null_yield);
   ASSERT_EQ(0, r);
 }
 
@@ -369,7 +376,7 @@ TEST_F(LegacyFIFO, TestTwoPushers)
   static constexpr auto max_entry_size = 128ull;
 
   std::unique_ptr<RCf::FIFO> f;
-  auto r = RCf::FIFO::create(ioctx, fifo_id, &f, null_yield, std::nullopt,
+  auto r = RCf::FIFO::create(&dp, ioctx, fifo_id, &f, null_yield, std::nullopt,
                             std::nullopt, false, max_part_size,
                             max_entry_size);
   ASSERT_EQ(0, r);
@@ -381,7 +388,7 @@ TEST_F(LegacyFIFO, TestTwoPushers)
                                 (max_entry_size + part_entry_overhead));
   const auto max_entries = entries_per_part * 4 + 1;
   std::unique_ptr<RCf::FIFO> f2;
-  r = RCf::FIFO::open(ioctx, fifo_id, &f2, null_yield);
+  r = RCf::FIFO::open(&dp, ioctx, fifo_id, &f2, null_yield);
   std::vector fifos{&f, &f2};
 
   for (auto i = 0u; i < max_entries; ++i) {
@@ -389,19 +396,19 @@ TEST_F(LegacyFIFO, TestTwoPushers)
     *(int *)buf = i;
     bl.append(buf, sizeof(buf));
     auto& f = *fifos[i % fifos.size()];
-    r = f->push(bl, null_yield);
+    r = f->push(&dp, bl, null_yield);
     ASSERT_EQ(0, r);
   }
 
   /* list all by both */
   std::vector<RCf::list_entry> result;
   bool more = false;
-  r = f2->list(max_entries, std::nullopt, &result, &more, null_yield);
+  r = f2->list(&dp, max_entries, std::nullopt, &result, &more, null_yield);
   ASSERT_EQ(0, r);
   ASSERT_EQ(false, more);
   ASSERT_EQ(max_entries, result.size());
 
-  r = f2->list(max_entries, std::nullopt, &result, &more, null_yield);
+  r = f2->list(&dp, max_entries, std::nullopt, &result, &more, null_yield);
   ASSERT_EQ(0, r);
   ASSERT_EQ(false, more);
   ASSERT_EQ(max_entries, result.size());
@@ -417,7 +424,7 @@ TEST_F(LegacyFIFO, TestTwoPushersTrim)
   static constexpr auto max_part_size = 2048ull;
   static constexpr auto max_entry_size = 128ull;
   std::unique_ptr<RCf::FIFO> f1;
-  auto r = RCf::FIFO::create(ioctx, fifo_id, &f1, null_yield, std::nullopt,
+  auto r = RCf::FIFO::create(&dp, ioctx, fifo_id, &f1, null_yield, std::nullopt,
                             std::nullopt, false, max_part_size,
                             max_entry_size);
   ASSERT_EQ(0, r);
@@ -431,7 +438,7 @@ TEST_F(LegacyFIFO, TestTwoPushersTrim)
   const auto max_entries = entries_per_part * 4 + 1;
 
   std::unique_ptr<RCf::FIFO> f2;
-  r = RCf::FIFO::open(ioctx, fifo_id, &f2, null_yield);
+  r = RCf::FIFO::open(&dp, ioctx, fifo_id, &f2, null_yield);
   ASSERT_EQ(0, r);
 
   /* push one entry to f2 and the rest to f1 */
@@ -440,7 +447,7 @@ TEST_F(LegacyFIFO, TestTwoPushersTrim)
     *(int *)buf = i;
     bl.append(buf, sizeof(buf));
     auto& f = (i < 1 ? f2 : f1);
-    r = f->push(bl, null_yield);
+    r = f->push(&dp, bl, null_yield);
     ASSERT_EQ(0, r);
   }
 
@@ -449,7 +456,7 @@ TEST_F(LegacyFIFO, TestTwoPushersTrim)
   std::string marker;
   std::vector<RCf::list_entry> result;
   bool more = false;
-  r = f1->list(num, std::nullopt, &result, &more, null_yield);
+  r = f1->list(&dp, num, std::nullopt, &result, &more, null_yield);
   ASSERT_EQ(0, r);
   ASSERT_EQ(true, more);
   ASSERT_EQ(num, result.size());
@@ -461,11 +468,11 @@ TEST_F(LegacyFIFO, TestTwoPushersTrim)
 
   auto& entry = result[num - 1];
   marker = entry.marker;
-  r = f1->trim(marker, false, null_yield);
+  r = f1->trim(&dp, marker, false, null_yield);
   /* list what's left by fifo2 */
 
   const auto left = max_entries - num;
-  f2->list(left, marker, &result, &more, null_yield);
+  f2->list(&dp, left, marker, &result, &more, null_yield);
   ASSERT_EQ(left, result.size());
   ASSERT_EQ(false, more);
 
@@ -481,7 +488,7 @@ TEST_F(LegacyFIFO, TestPushBatch)
   static constexpr auto max_entry_size = 128ull;
 
   std::unique_ptr<RCf::FIFO> f;
-  auto r = RCf::FIFO::create(ioctx, fifo_id, &f, null_yield, std::nullopt,
+  auto r = RCf::FIFO::create(&dp, ioctx, fifo_id, &f, null_yield, std::nullopt,
                             std::nullopt, false, max_part_size,
                             max_entry_size);
   ASSERT_EQ(0, r);
@@ -501,14 +508,14 @@ TEST_F(LegacyFIFO, TestPushBatch)
   }
   ASSERT_EQ(max_entries, bufs.size());
 
-  r = f->push(bufs, null_yield);
+  r = f->push(&dp, bufs, null_yield);
   ASSERT_EQ(0, r);
 
   /* list all */
 
   std::vector<RCf::list_entry> result;
   bool more = false;
-  r = f->list(max_entries, std::nullopt, &result, &more, null_yield);
+  r = f->list(&dp, max_entries, std::nullopt, &result, &more, null_yield);
   ASSERT_EQ(0, r);
   ASSERT_EQ(false, more);
   ASSERT_EQ(max_entries, result.size());
@@ -525,7 +532,7 @@ TEST_F(LegacyFIFO, TestAioTrim)
   static constexpr auto max_part_size = 2048ull;
   static constexpr auto max_entry_size = 128ull;
   std::unique_ptr<RCf::FIFO> f;
-  auto r = RCf::FIFO::create(ioctx, fifo_id, &f, null_yield, std::nullopt,
+  auto r = RCf::FIFO::create(&dp, ioctx, fifo_id, &f, null_yield, std::nullopt,
                             std::nullopt, false, max_part_size,
                             max_entry_size);
   ASSERT_EQ(0, r);
@@ -547,7 +554,7 @@ TEST_F(LegacyFIFO, TestAioTrim)
   }
   ASSERT_EQ(max_entries, bufs.size());
 
-  r = f->push(bufs, null_yield);
+  r = f->push(&dp, bufs, null_yield);
   ASSERT_EQ(0, r);
 
   auto info = f->meta();
@@ -558,7 +565,7 @@ TEST_F(LegacyFIFO, TestAioTrim)
   /* list all at once */
   std::vector<RCf::list_entry> result;
   bool more = false;
-  r = f->list(max_entries, std::nullopt, &result, &more, null_yield);
+  r = f->list(&dp, max_entries, std::nullopt, &result, &more, null_yield);
   ASSERT_EQ(0, r);
   ASSERT_EQ(false, more);
   ASSERT_EQ(max_entries, result.size());
@@ -570,7 +577,7 @@ TEST_F(LegacyFIFO, TestAioTrim)
   marker.reset();
   for (auto i = 0u; i < max_entries; ++i) {
     /* read single entry */
-    r = f->list(1, marker, &result, &more, null_yield);
+    r = f->list(&dp, 1, marker, &result, &more, null_yield);
     ASSERT_EQ(0, r);
     ASSERT_EQ(result.size(), 1);
     const bool expected_more = (i != (max_entries - 1));
@@ -579,7 +586,7 @@ TEST_F(LegacyFIFO, TestAioTrim)
     marker = result.front().marker;
     std::unique_ptr<R::AioCompletion> c(rados.aio_create_completion(nullptr,
                                                                    nullptr));
-    f->trim(*marker, false, c.get());
+    f->trim(&dp, *marker, false, c.get());
     c->wait_for_complete();
     r = c->get_return_value();
     ASSERT_EQ(0, r);
@@ -589,7 +596,7 @@ TEST_F(LegacyFIFO, TestAioTrim)
     ASSERT_EQ(info.tail_part_num, i / entries_per_part);
 
     /* try to read all again, see how many entries left */
-    r = f->list(max_entries, marker, &result, &more, null_yield);
+    r = f->list(&dp, max_entries, marker, &result, &more, null_yield);
     ASSERT_EQ(max_entries - i - 1, result.size());
     ASSERT_EQ(false, more);
   }
@@ -601,17 +608,17 @@ TEST_F(LegacyFIFO, TestAioTrim)
   RCf::part_info partinfo;
   /* check old tails are removed */
   for (auto i = 0; i < info.tail_part_num; ++i) {
-    r = f->get_part_info(i, &partinfo, null_yield);
+    r = f->get_part_info(&dp, i, &partinfo, null_yield);
     ASSERT_EQ(-ENOENT, r);
   }
   /* check current tail exists */
-  r = f->get_part_info(info.tail_part_num, &partinfo, null_yield);
+  r = f->get_part_info(&dp, info.tail_part_num, &partinfo, null_yield);
   ASSERT_EQ(0, r);
 }
 
 TEST_F(LegacyFIFO, TestTrimExclusive) {
   std::unique_ptr<RCf::FIFO> f;
-  auto r = RCf::FIFO::create(ioctx, fifo_id, &f, null_yield);
+  auto r = RCf::FIFO::create(&dp, ioctx, fifo_id, &f, null_yield);
   ASSERT_EQ(0, r);
   std::vector<RCf::list_entry> result;
   bool more = false;
@@ -620,28 +627,28 @@ TEST_F(LegacyFIFO, TestTrimExclusive) {
   for (uint32_t i = 0; i < max_entries; ++i) {
     cb::list bl;
     encode(i, bl);
-    f->push(bl, null_yield);
+    f->push(&dp, bl, null_yield);
   }
 
-  f->list(1, std::nullopt, &result, &more, null_yield);
+  f->list(&dp, 1, std::nullopt, &result, &more, null_yield);
   auto [val, marker] = decode_entry<std::uint32_t>(result.front());
   ASSERT_EQ(0, val);
-  f->trim(marker, true, null_yield);
+  f->trim(&dp, marker, true, null_yield);
 
   result.clear();
-  f->list(max_entries, std::nullopt, &result, &more, null_yield);
+  f->list(&dp, max_entries, std::nullopt, &result, &more, null_yield);
   std::tie(val, marker) = decode_entry<std::uint32_t>(result.front());
   ASSERT_EQ(0, val);
-  f->trim(result[4].marker, true, null_yield);
+  f->trim(&dp, result[4].marker, true, null_yield);
 
   result.clear();
-  f->list(max_entries, std::nullopt, &result, &more, null_yield);
+  f->list(&dp, max_entries, std::nullopt, &result, &more, null_yield);
   std::tie(val, marker) = decode_entry<std::uint32_t>(result.front());
   ASSERT_EQ(4, val);
-  f->trim(result.back().marker, true, null_yield);
+  f->trim(&dp, result.back().marker, true, null_yield);
 
   result.clear();
-  f->list(max_entries, std::nullopt, &result, &more, null_yield);
+  f->list(&dp, max_entries, std::nullopt, &result, &more, null_yield);
   std::tie(val, marker) = decode_entry<std::uint32_t>(result.front());
   ASSERT_EQ(result.size(), 1);
   ASSERT_EQ(max_entries - 1, val);
@@ -650,14 +657,14 @@ TEST_F(LegacyFIFO, TestTrimExclusive) {
 TEST_F(AioLegacyFIFO, TestPushListTrim)
 {
   std::unique_ptr<RCf::FIFO> f;
-  auto r = RCf::FIFO::create(ioctx, fifo_id, &f, null_yield);
+  auto r = RCf::FIFO::create(&dp, ioctx, fifo_id, &f, null_yield);
   ASSERT_EQ(0, r);
   static constexpr auto max_entries = 10u;
   for (uint32_t i = 0; i < max_entries; ++i) {
     cb::list bl;
     encode(i, bl);
     auto c = R::Rados::aio_create_completion();
-    f->push(bl, c);
+    f->push(&dp, bl, c);
     c->wait_for_complete();
     r = c->get_return_value();
     c->release();
@@ -670,7 +677,7 @@ TEST_F(AioLegacyFIFO, TestPushListTrim)
   bool more = false;
   for (auto i = 0u; i < max_entries; ++i) {
     auto c = R::Rados::aio_create_completion();
-    f->list(1, marker, &result, &more, c);
+    f->list(&dp, 1, marker, &result, &more, c);
     c->wait_for_complete();
     r = c->get_return_value();
     c->release();
@@ -691,7 +698,7 @@ TEST_F(AioLegacyFIFO, TestPushListTrim)
   std::string markers[max_entries];
   std::uint32_t min_entry = 0;
   auto c = R::Rados::aio_create_completion();
-  f->list(max_entries * 10, std::nullopt, &result, &more, c);
+  f->list(&dp, max_entries * 10, std::nullopt, &result, &more, c);
   c->wait_for_complete();
   r = c->get_return_value();
   c->release();
@@ -707,7 +714,7 @@ TEST_F(AioLegacyFIFO, TestPushListTrim)
 
   /* trim one entry */
   c = R::Rados::aio_create_completion();
-  f->trim(markers[min_entry], false, c);
+  f->trim(&dp, markers[min_entry], false, c);
   c->wait_for_complete();
   r = c->get_return_value();
   c->release();
@@ -715,7 +722,7 @@ TEST_F(AioLegacyFIFO, TestPushListTrim)
   ++min_entry;
 
   c = R::Rados::aio_create_completion();
-  f->list(max_entries * 10, std::nullopt, &result, &more, c);
+  f->list(&dp, max_entries * 10, std::nullopt, &result, &more, c);
   c->wait_for_complete();
   r = c->get_return_value();
   c->release();
@@ -738,7 +745,7 @@ TEST_F(AioLegacyFIFO, TestPushTooBig)
   static constexpr auto max_entry_size = 128ull;
 
   std::unique_ptr<RCf::FIFO> f;
-  auto r = RCf::FIFO::create(ioctx, fifo_id, &f, null_yield, std::nullopt,
+  auto r = RCf::FIFO::create(&dp, ioctx, fifo_id, &f, null_yield, std::nullopt,
                             std::nullopt, false, max_part_size, max_entry_size);
   ASSERT_EQ(0, r);
 
@@ -749,14 +756,14 @@ TEST_F(AioLegacyFIFO, TestPushTooBig)
   bl.append(buf, sizeof(buf));
 
   auto c = R::Rados::aio_create_completion();
-  f->push(bl, c);
+  f->push(&dp, bl, c);
   c->wait_for_complete();
   r = c->get_return_value();
   ASSERT_EQ(-E2BIG, r);
   c->release();
 
   c = R::Rados::aio_create_completion();
-  f->push(std::vector<cb::list>{}, c);
+  f->push(&dp, std::vector<cb::list>{}, c);
   c->wait_for_complete();
   r = c->get_return_value();
   c->release();
@@ -769,15 +776,14 @@ TEST_F(AioLegacyFIFO, TestMultipleParts)
   static constexpr auto max_part_size = 2048ull;
   static constexpr auto max_entry_size = 128ull;
   std::unique_ptr<RCf::FIFO> f;
-  auto r = RCf::FIFO::create(ioctx, fifo_id, &f, null_yield, std::nullopt,
+  auto r = RCf::FIFO::create(&dp, ioctx, fifo_id, &f, null_yield, std::nullopt,
                             std::nullopt, false, max_part_size,
                             max_entry_size);
   ASSERT_EQ(0, r);
 
   {
     auto c = R::Rados::aio_create_completion();
-    f->get_head_info([&](int r, RCf::part_info&& p) {
-      ASSERT_TRUE(p.tag.empty());
+    f->get_head_info(&dp, [&](int r, RCf::part_info&& p) {
       ASSERT_EQ(0, p.magic);
       ASSERT_EQ(0, p.min_ofs);
       ASSERT_EQ(0, p.last_ofs);
@@ -804,7 +810,7 @@ TEST_F(AioLegacyFIFO, TestMultipleParts)
     *(int *)buf = i;
     bl.append(buf, sizeof(buf));
     auto c = R::Rados::aio_create_completion();
-    f->push(bl, c);
+    f->push(&dp, bl, c);
     c->wait_for_complete();
     r = c->get_return_value();
     c->release();
@@ -820,7 +826,7 @@ TEST_F(AioLegacyFIFO, TestMultipleParts)
   std::vector<RCf::list_entry> result;
   bool more = false;
   auto c = R::Rados::aio_create_completion();
-  f->list(max_entries, std::nullopt, &result, &more, c);
+  f->list(&dp, max_entries, std::nullopt, &result, &more, c);
   c->wait_for_complete();
   r = c->get_return_value();
   c->release();
@@ -838,7 +844,7 @@ TEST_F(AioLegacyFIFO, TestMultipleParts)
 
   for (auto i = 0u; i < max_entries; ++i) {
     c = R::Rados::aio_create_completion();
-    f->list(1, marker, &result, &more, c);
+    f->list(&dp, 1, marker, &result, &more, c);
     c->wait_for_complete();
     r = c->get_return_value();
     c->release();
@@ -861,7 +867,7 @@ TEST_F(AioLegacyFIFO, TestMultipleParts)
   for (auto i = 0u; i < max_entries; ++i) {
     /* read single entry */
     c = R::Rados::aio_create_completion();
-    f->list(1, marker, &result, &more, c);
+    f->list(&dp, 1, marker, &result, &more, c);
     c->wait_for_complete();
     r = c->get_return_value();
     c->release();
@@ -872,7 +878,7 @@ TEST_F(AioLegacyFIFO, TestMultipleParts)
 
     marker = result.front().marker;
     c = R::Rados::aio_create_completion();
-    f->trim(*marker, false, c);
+    f->trim(&dp, *marker, false, c);
     c->wait_for_complete();
     r = c->get_return_value();
     c->release();
@@ -885,7 +891,7 @@ TEST_F(AioLegacyFIFO, TestMultipleParts)
 
     /* try to read all again, see how many entries left */
     c = R::Rados::aio_create_completion();
-    f->list(max_entries, marker, &result, &more, c);
+    f->list(&dp, max_entries, marker, &result, &more, c);
     c->wait_for_complete();
     r = c->get_return_value();
     c->release();
@@ -922,7 +928,7 @@ TEST_F(AioLegacyFIFO, TestMultipleParts)
   ASSERT_EQ(0, r);
 
   c = R::Rados::aio_create_completion();
-  f->get_head_info([&](int r, RCf::part_info&& p) {
+  f->get_head_info(&dp, [&](int r, RCf::part_info&& p) {
     ASSERT_EQ(next_ofs, p.next_ofs);
   }, c);
   c->wait_for_complete();
@@ -937,7 +943,7 @@ TEST_F(AioLegacyFIFO, TestTwoPushers)
   static constexpr auto max_entry_size = 128ull;
 
   std::unique_ptr<RCf::FIFO> f;
-  auto r = RCf::FIFO::create(ioctx, fifo_id, &f, null_yield, std::nullopt,
+  auto r = RCf::FIFO::create(&dp, ioctx, fifo_id, &f, null_yield, std::nullopt,
                             std::nullopt, false, max_part_size,
                             max_entry_size);
   ASSERT_EQ(0, r);
@@ -949,7 +955,7 @@ TEST_F(AioLegacyFIFO, TestTwoPushers)
                                 (max_entry_size + part_entry_overhead));
   const auto max_entries = entries_per_part * 4 + 1;
   std::unique_ptr<RCf::FIFO> f2;
-  r = RCf::FIFO::open(ioctx, fifo_id, &f2, null_yield);
+  r = RCf::FIFO::open(&dp, ioctx, fifo_id, &f2, null_yield);
   std::vector fifos{&f, &f2};
 
   for (auto i = 0u; i < max_entries; ++i) {
@@ -958,7 +964,7 @@ TEST_F(AioLegacyFIFO, TestTwoPushers)
     bl.append(buf, sizeof(buf));
     auto& f = *fifos[i % fifos.size()];
     auto c = R::Rados::aio_create_completion();
-    f->push(bl, c);
+    f->push(&dp, bl, c);
     c->wait_for_complete();
     r = c->get_return_value();
     c->release();
@@ -969,7 +975,7 @@ TEST_F(AioLegacyFIFO, TestTwoPushers)
   std::vector<RCf::list_entry> result;
   bool more = false;
   auto c = R::Rados::aio_create_completion();
-  f2->list(max_entries, std::nullopt, &result, &more, c);
+  f2->list(&dp, max_entries, std::nullopt, &result, &more, c);
   c->wait_for_complete();
   r = c->get_return_value();
   c->release();
@@ -978,7 +984,7 @@ TEST_F(AioLegacyFIFO, TestTwoPushers)
   ASSERT_EQ(max_entries, result.size());
 
   c = R::Rados::aio_create_completion();
-  f2->list(max_entries, std::nullopt, &result, &more, c);
+  f2->list(&dp, max_entries, std::nullopt, &result, &more, c);
   c->wait_for_complete();
   r = c->get_return_value();
   c->release();
@@ -997,7 +1003,7 @@ TEST_F(AioLegacyFIFO, TestTwoPushersTrim)
   static constexpr auto max_part_size = 2048ull;
   static constexpr auto max_entry_size = 128ull;
   std::unique_ptr<RCf::FIFO> f1;
-  auto r = RCf::FIFO::create(ioctx, fifo_id, &f1, null_yield, std::nullopt,
+  auto r = RCf::FIFO::create(&dp, ioctx, fifo_id, &f1, null_yield, std::nullopt,
                             std::nullopt, false, max_part_size,
                             max_entry_size);
   ASSERT_EQ(0, r);
@@ -1011,7 +1017,7 @@ TEST_F(AioLegacyFIFO, TestTwoPushersTrim)
   const auto max_entries = entries_per_part * 4 + 1;
 
   std::unique_ptr<RCf::FIFO> f2;
-  r = RCf::FIFO::open(ioctx, fifo_id, &f2, null_yield);
+  r = RCf::FIFO::open(&dp, ioctx, fifo_id, &f2, null_yield);
   ASSERT_EQ(0, r);
 
   /* push one entry to f2 and the rest to f1 */
@@ -1021,7 +1027,7 @@ TEST_F(AioLegacyFIFO, TestTwoPushersTrim)
     bl.append(buf, sizeof(buf));
     auto& f = (i < 1 ? f2 : f1);
     auto c = R::Rados::aio_create_completion();
-    f->push(bl, c);
+    f->push(&dp, bl, c);
     c->wait_for_complete();
     r = c->get_return_value();
     c->release();
@@ -1034,7 +1040,7 @@ TEST_F(AioLegacyFIFO, TestTwoPushersTrim)
   std::vector<RCf::list_entry> result;
   bool more = false;
   auto c = R::Rados::aio_create_completion();
-  f1->list(num, std::nullopt, &result, &more, c);
+  f1->list(&dp, num, std::nullopt, &result, &more, c);
   c->wait_for_complete();
   r = c->get_return_value();
   c->release();
@@ -1050,7 +1056,7 @@ TEST_F(AioLegacyFIFO, TestTwoPushersTrim)
   auto& entry = result[num - 1];
   marker = entry.marker;
   c = R::Rados::aio_create_completion();
-  f1->trim(marker, false, c);
+  f1->trim(&dp, marker, false, c);
   c->wait_for_complete();
   r = c->get_return_value();
   c->release();
@@ -1059,7 +1065,7 @@ TEST_F(AioLegacyFIFO, TestTwoPushersTrim)
 
   const auto left = max_entries - num;
   c = R::Rados::aio_create_completion();
-  f2->list(left, marker, &result, &more, c);
+  f2->list(&dp, left, marker, &result, &more, c);
   c->wait_for_complete();
   r = c->get_return_value();
   c->release();
@@ -1079,7 +1085,7 @@ TEST_F(AioLegacyFIFO, TestPushBatch)
   static constexpr auto max_entry_size = 128ull;
 
   std::unique_ptr<RCf::FIFO> f;
-  auto r = RCf::FIFO::create(ioctx, fifo_id, &f, null_yield, std::nullopt,
+  auto r = RCf::FIFO::create(&dp, ioctx, fifo_id, &f, null_yield, std::nullopt,
                             std::nullopt, false, max_part_size,
                             max_entry_size);
   ASSERT_EQ(0, r);
@@ -1100,7 +1106,7 @@ TEST_F(AioLegacyFIFO, TestPushBatch)
   ASSERT_EQ(max_entries, bufs.size());
 
   auto c = R::Rados::aio_create_completion();
-  f->push(bufs, c);
+  f->push(&dp, bufs, c);
   c->wait_for_complete();
   r = c->get_return_value();
   c->release();
@@ -1111,7 +1117,7 @@ TEST_F(AioLegacyFIFO, TestPushBatch)
   std::vector<RCf::list_entry> result;
   bool more = false;
   c = R::Rados::aio_create_completion();
-  f->list(max_entries, std::nullopt, &result, &more, c);
+  f->list(&dp, max_entries, std::nullopt, &result, &more, c);
   c->wait_for_complete();
   r = c->get_return_value();
   c->release();
@@ -1129,23 +1135,23 @@ TEST_F(AioLegacyFIFO, TestPushBatch)
 TEST_F(LegacyFIFO, TrimAll)
 {
   std::unique_ptr<RCf::FIFO> f;
-  auto r = RCf::FIFO::create(ioctx, fifo_id, &f, null_yield);
+  auto r = RCf::FIFO::create(&dp, ioctx, fifo_id, &f, null_yield);
   ASSERT_EQ(0, r);
   static constexpr auto max_entries = 10u;
   for (uint32_t i = 0; i < max_entries; ++i) {
     cb::list bl;
     encode(i, bl);
-    r = f->push(bl, null_yield);
+    r = f->push(&dp, bl, null_yield);
     ASSERT_EQ(0, r);
   }
 
   /* trim one entry */
-  r = f->trim(RCf::marker::max().to_string(), false, null_yield);
+  r = f->trim(&dp, RCf::marker::max().to_string(), false, null_yield);
   ASSERT_EQ(-ENODATA, r);
 
   std::vector<RCf::list_entry> result;
   bool more;
-  r = f->list(1, std::nullopt, &result, &more, null_yield);
+  r = f->list(&dp, 1, std::nullopt, &result, &more, null_yield);
   ASSERT_EQ(0, r);
   ASSERT_TRUE(result.empty());
 }
@@ -1153,18 +1159,18 @@ TEST_F(LegacyFIFO, TrimAll)
 TEST_F(LegacyFIFO, AioTrimAll)
 {
   std::unique_ptr<RCf::FIFO> f;
-  auto r = RCf::FIFO::create(ioctx, fifo_id, &f, null_yield);
+  auto r = RCf::FIFO::create(&dp, ioctx, fifo_id, &f, null_yield);
   ASSERT_EQ(0, r);
   static constexpr auto max_entries = 10u;
   for (uint32_t i = 0; i < max_entries; ++i) {
     cb::list bl;
     encode(i, bl);
-    r = f->push(bl, null_yield);
+    r = f->push(&dp, bl, null_yield);
     ASSERT_EQ(0, r);
   }
 
   auto c = R::Rados::aio_create_completion();
-  f->trim(RCf::marker::max().to_string(), false, c);
+  f->trim(&dp, RCf::marker::max().to_string(), false, c);
   c->wait_for_complete();
   r = c->get_return_value();
   c->release();
@@ -1172,7 +1178,7 @@ TEST_F(LegacyFIFO, AioTrimAll)
 
   std::vector<RCf::list_entry> result;
   bool more;
-  r = f->list(1, std::nullopt, &result, &more, null_yield);
+  r = f->list(&dp, 1, std::nullopt, &result, &more, null_yield);
   ASSERT_EQ(0, r);
   ASSERT_TRUE(result.empty());
 }