From 74fde3a4a05bac4cf96e9a32a31001a61b118fba Mon Sep 17 00:00:00 2001
From: Kefu Chai <kchai@redhat.com>
Date: Wed, 6 May 2020 22:30:56 +0800
Subject: [PATCH] crimson: avoid using variadic future

it is deprecated by seastar. let's use future<tuple<...>> instead.

Signed-off-by: Kefu Chai <kchai@redhat.com>
---
 src/crimson/mon/MonClient.cc             |  4 +--
 src/crimson/mon/MonClient.h              |  4 +--
 src/crimson/net/ProtocolV2.cc            | 15 ++++++-----
 src/crimson/net/ProtocolV2.h             |  3 ++-
 src/crimson/os/alienstore/alien_store.cc | 17 +++++++-----
 src/crimson/os/alienstore/alien_store.h  |  7 ++---
 src/crimson/os/cyanstore/cyan_store.cc   | 21 ++++++++-------
 src/crimson/os/cyanstore/cyan_store.h    |  7 ++---
 src/crimson/os/futurized_store.h         | 15 ++++++-----
 src/crimson/osd/ops_executer.cc          |  6 +++--
 src/crimson/osd/osd.cc                   | 34 ++++++++++++------------
 src/crimson/osd/osd_meta.cc              | 17 ++++++------
 src/crimson/osd/osd_meta.h               |  6 ++---
 src/crimson/osd/pg_backend.cc            | 23 ++++++++--------
 src/crimson/osd/pg_backend.h             |  2 +-
 15 files changed, 98 insertions(+), 83 deletions(-)

diff --git a/src/crimson/mon/MonClient.cc b/src/crimson/mon/MonClient.cc
index b20fde1d60e3b..a71dabdf810ef 100644
--- a/src/crimson/mon/MonClient.cc
+++ b/src/crimson/mon/MonClient.cc
@@ -845,7 +845,7 @@ Client::handle_get_version_reply(Ref<MMonGetVersionReply> m)
     auto& result = found->second;
     logger().trace("{}: {} returns {}",
                  __func__, m->handle, m->version);
-    result.set_value(m->version, m->oldest_version);
+    result.set_value(std::make_tuple(m->version, m->oldest_version));
     version_reqs.erase(found);
   } else {
     logger().warn("{}: version request with handle {} not found",
@@ -861,7 +861,7 @@ seastar::future<> Client::handle_mon_command_ack(Ref<MMonCommandAck> m)
       found != mon_commands.end()) {
     auto& result = found->second;
     logger().trace("{} {}", __func__, tid);
-    result.set_value(m->r, m->rs, std::move(m->get_data()));
+    result.set_value(std::make_tuple(m->r, m->rs, std::move(m->get_data())));
     mon_commands.erase(found);
   } else {
     logger().warn("{} {} not found", __func__, tid);
diff --git a/src/crimson/mon/MonClient.h b/src/crimson/mon/MonClient.h
index d834f159b1c64..3c3a5b6eddc2d 100644
--- a/src/crimson/mon/MonClient.h
+++ b/src/crimson/mon/MonClient.h
@@ -59,14 +59,14 @@ class Client : public crimson::net::Dispatcher,
   crimson::net::Messenger& msgr;
 
   // commands
-  using get_version_t = seastar::future<version_t, version_t>;
+  using get_version_t = seastar::future<std::tuple<version_t, version_t>>;
 
   ceph_tid_t last_version_req_id = 0;
   std::map<ceph_tid_t, typename get_version_t::promise_type> version_reqs;
 
   ceph_tid_t last_mon_command_id = 0;
   using command_result_t =
-    seastar::future<std::int32_t, string, ceph::bufferlist>;
+    seastar::future<std::tuple<std::int32_t, string, ceph::bufferlist>>;
   std::map<ceph_tid_t, typename command_result_t::promise_type> mon_commands;
 
   MonSub sub;
diff --git a/src/crimson/net/ProtocolV2.cc b/src/crimson/net/ProtocolV2.cc
index 9ede311b25d1e..beb94fd9db1ff 100644
--- a/src/crimson/net/ProtocolV2.cc
+++ b/src/crimson/net/ProtocolV2.cc
@@ -451,7 +451,8 @@ void ProtocolV2::reset_session(bool full)
   }
 }
 
-seastar::future<entity_type_t, entity_addr_t> ProtocolV2::banner_exchange(bool is_connect)
+seastar::future<std::tuple<entity_type_t, entity_addr_t>>
+ProtocolV2::banner_exchange(bool is_connect)
 {
   // 1. prepare and send banner
   bufferlist banner_payload;
@@ -558,8 +559,8 @@ seastar::future<entity_type_t, entity_addr_t> ProtocolV2::banner_exchange(bool i
       logger().debug("{} GOT HelloFrame: my_type={} peer_addr={}",
                      conn, ceph_entity_type_name(hello.entity_type()),
                      hello.peer_addr());
-      return seastar::make_ready_future<entity_type_t, entity_addr_t>(
-          hello.entity_type(), hello.peer_addr());
+      return seastar::make_ready_future<std::tuple<entity_type_t, entity_addr_t>>(
+        std::make_tuple(hello.entity_type(), hello.peer_addr()));
     });
 }
 
@@ -903,8 +904,8 @@ void ProtocolV2::execute_connecting()
           session_stream_handlers = { nullptr, nullptr };
           enable_recording();
           return banner_exchange(true);
-        }).then([this] (entity_type_t _peer_type,
-                        entity_addr_t _my_addr_from_peer) {
+        }).then([this] (auto&& ret) {
+          auto [_peer_type, _my_addr_from_peer] = std::move(ret);
           if (conn.get_peer_type() != _peer_type) {
             logger().warn("{} connection peer type does not match what peer advertises {} != {}",
                           conn, ceph_entity_type_name(conn.get_peer_type()),
@@ -1532,8 +1533,8 @@ void ProtocolV2::execute_accepting()
           session_stream_handlers = { nullptr, nullptr };
           enable_recording();
           return banner_exchange(false);
-        }).then([this] (entity_type_t _peer_type,
-                        entity_addr_t _my_addr_from_peer) {
+        }).then([this] (auto&& ret) {
+          auto [_peer_type, _my_addr_from_peer] = std::move(ret);
           ceph_assert(conn.get_peer_type() == 0);
           conn.set_peer_type(_peer_type);
 
diff --git a/src/crimson/net/ProtocolV2.h b/src/crimson/net/ProtocolV2.h
index bd958f9d40543..dfca59a3361ba 100644
--- a/src/crimson/net/ProtocolV2.h
+++ b/src/crimson/net/ProtocolV2.h
@@ -135,7 +135,8 @@ class ProtocolV2 final : public Protocol {
  private:
   void fault(bool backoff, const char* func_name, std::exception_ptr eptr);
   void reset_session(bool full);
-  seastar::future<entity_type_t, entity_addr_t> banner_exchange(bool is_connect);
+  seastar::future<std::tuple<entity_type_t, entity_addr_t>>
+  banner_exchange(bool is_connect);
 
   enum class next_step_t {
     ready,
diff --git a/src/crimson/os/alienstore/alien_store.cc b/src/crimson/os/alienstore/alien_store.cc
index baca9ec78756d..041b48388bc29 100644
--- a/src/crimson/os/alienstore/alien_store.cc
+++ b/src/crimson/os/alienstore/alien_store.cc
@@ -117,7 +117,7 @@ seastar::future<> AlienStore::mkfs(uuid_d new_osd_fsid)
   });
 }
 
-seastar::future<std::vector<ghobject_t>, ghobject_t>
+seastar::future<std::tuple<std::vector<ghobject_t>, ghobject_t>>
 AlienStore::list_objects(CollectionRef ch,
                         const ghobject_t& start,
                         const ghobject_t& end,
@@ -133,8 +133,8 @@ AlienStore::list_objects(CollectionRef ch,
                                     store->get_ideal_list_max(),
                                     &objects, &next);
     }).then([&objects, &next] (int) {
-      return seastar::make_ready_future<std::vector<ghobject_t>, ghobject_t>(
-                                         std::move(objects), std::move(next));
+      return seastar::make_ready_future<std::tuple<std::vector<ghobject_t>, ghobject_t>>(
+	std::make_tuple(std::move(objects), std::move(next)));
     });
   });
 }
@@ -306,7 +306,7 @@ AlienStore::omap_get_values(CollectionRef ch,
   });
 }
 
-seastar::future<bool, AlienStore::omap_values_t>
+seastar::future<std::tuple<bool, AlienStore::omap_values_t>>
 AlienStore::omap_get_values(CollectionRef ch,
                             const ghobject_t &oid,
                             const std::optional<string> &start)
@@ -318,7 +318,8 @@ AlienStore::omap_get_values(CollectionRef ch,
       return store->omap_get_values(c->collection, oid, start,
 		                    reinterpret_cast<map<string, bufferlist>*>(&values));
     }).then([&values] (int r) {
-      return seastar::make_ready_future<bool, omap_values_t>(true, std::move(values));
+      return seastar::make_ready_future<std::tuple<bool, omap_values_t>>(
+        std::make_tuple(true, std::move(values)));
     });
   });
 }
@@ -361,7 +362,8 @@ seastar::future<> AlienStore::write_meta(const std::string& key,
   });
 }
 
-seastar::future<int, std::string> AlienStore::read_meta(const std::string& key)
+seastar::future<std::tuple<int, std::string>>
+AlienStore::read_meta(const std::string& key)
 {
   logger().debug("{}", __func__);
   return tp->submit([this, key] {
@@ -376,7 +378,8 @@ seastar::future<int, std::string> AlienStore::read_meta(const std::string& key)
     }
     return std::make_pair(r, value);
   }).then([] (auto entry) {
-    return seastar::make_ready_future<int, std::string>(entry.first, entry.second);
+    return seastar::make_ready_future<std::tuple<int, std::string>>(
+      std::move(entry));
   });
 }
 
diff --git a/src/crimson/os/alienstore/alien_store.h b/src/crimson/os/alienstore/alien_store.h
index 8885a196a622b..3552274344ce3 100644
--- a/src/crimson/os/alienstore/alien_store.h
+++ b/src/crimson/os/alienstore/alien_store.h
@@ -70,14 +70,14 @@ public:
     const ghobject_t& oid,
     const omap_keys_t& keys) final;
 
-  seastar::future<std::vector<ghobject_t>, ghobject_t> list_objects(
+  seastar::future<std::tuple<std::vector<ghobject_t>, ghobject_t>> list_objects(
     CollectionRef c,
     const ghobject_t& start,
     const ghobject_t& end,
     uint64_t limit) const final;
 
   /// Retrieves paged set of values > start (if present)
-  seastar::future<bool, omap_values_t> omap_get_values(
+  seastar::future<std::tuple<bool, omap_values_t>> omap_get_values(
     CollectionRef c,           ///< [in] collection
     const ghobject_t &oid,     ///< [in] oid
     const std::optional<std::string> &start ///< [in] start, empty for begin
@@ -92,7 +92,8 @@ public:
 
   seastar::future<> write_meta(const std::string& key,
                   const std::string& value) final;
-  seastar::future<int, std::string> read_meta(const std::string& key) final;
+  seastar::future<std::tuple<int, std::string>> read_meta(
+    const std::string& key) final;
   uuid_d get_fsid() const final;
   seastar::future<store_statfs_t> stat() const final;
   unsigned get_max_attr_name_length() const final;
diff --git a/src/crimson/os/cyanstore/cyan_store.cc b/src/crimson/os/cyanstore/cyan_store.cc
index 109767c4b1b77..e99e72c8f9973 100644
--- a/src/crimson/os/cyanstore/cyan_store.cc
+++ b/src/crimson/os/cyanstore/cyan_store.cc
@@ -83,7 +83,8 @@ seastar::future<> CyanStore::umount()
 
 seastar::future<> CyanStore::mkfs(uuid_d new_osd_fsid)
 {
-  return read_meta("fsid").then([=](auto r, auto fsid_str) {
+  return read_meta("fsid").then([=](auto&& ret) {
+    auto& [r, fsid_str] = ret;
     if (r == -ENOENT) {
       if (new_osd_fsid.is_zero()) {
         osd_fsid.generate_random();
@@ -124,7 +125,7 @@ seastar::future<store_statfs_t> CyanStore::stat() const
   return seastar::make_ready_future<store_statfs_t>(std::move(st));
 }
 
-seastar::future<std::vector<ghobject_t>, ghobject_t>
+seastar::future<std::tuple<std::vector<ghobject_t>, ghobject_t>>
 CyanStore::list_objects(CollectionRef ch,
                         const ghobject_t& start,
                         const ghobject_t& end,
@@ -146,8 +147,8 @@ CyanStore::list_objects(CollectionRef ch,
     }
     objects.push_back(oid);
   }
-  return seastar::make_ready_future<std::vector<ghobject_t>, ghobject_t>(
-    std::move(objects), next);
+  return seastar::make_ready_future<std::tuple<std::vector<ghobject_t>, ghobject_t>>(
+    std::make_tuple(std::move(objects), next));
 }
 
 seastar::future<CollectionRef> CyanStore::create_new_collection(const coll_t& cid)
@@ -273,7 +274,7 @@ CyanStore::omap_get_values(CollectionRef ch,
   return seastar::make_ready_future<omap_values_t>(std::move(values));
 }
 
-seastar::future<bool, CyanStore::omap_values_t>
+seastar::future<std::tuple<bool, CyanStore::omap_values_t>>
 CyanStore::omap_get_values(
     CollectionRef ch,
     const ghobject_t &oid,
@@ -293,8 +294,8 @@ CyanStore::omap_get_values(
        ++i) {
     values.insert(*i);
   }
-  return seastar::make_ready_future<bool, omap_values_t>(
-    true, values);
+  return seastar::make_ready_future<std::tuple<bool, omap_values_t>>(
+    std::make_tuple(true, std::move(values)));
 }
 
 seastar::future<ceph::bufferlist>
@@ -657,7 +658,8 @@ seastar::future<> CyanStore::write_meta(const std::string& key,
   return seastar::make_ready_future<>();
 }
 
-seastar::future<int, std::string> CyanStore::read_meta(const std::string& key)
+seastar::future<std::tuple<int, std::string>>
+CyanStore::read_meta(const std::string& key)
 {
   std::string fsid(4096, '\0');
   int r = safe_read_file(path.c_str(), key.c_str(), fsid.data(), fsid.size());
@@ -669,7 +671,8 @@ seastar::future<int, std::string> CyanStore::read_meta(const std::string& key)
   } else {
     fsid.clear();
   }
-  return seastar::make_ready_future<int, std::string>(r, fsid);
+  return seastar::make_ready_future<std::tuple<int, std::string>>(
+    std::make_tuple(r, fsid));
 }
 
 uuid_d CyanStore::get_fsid() const
diff --git a/src/crimson/os/cyanstore/cyan_store.h b/src/crimson/os/cyanstore/cyan_store.h
index b2d1ba25203a0..e832ca1f04352 100644
--- a/src/crimson/os/cyanstore/cyan_store.h
+++ b/src/crimson/os/cyanstore/cyan_store.h
@@ -103,14 +103,14 @@ public:
     const ghobject_t& oid,
     const omap_keys_t& keys) final;
 
-  seastar::future<std::vector<ghobject_t>, ghobject_t> list_objects(
+  seastar::future<std::tuple<std::vector<ghobject_t>, ghobject_t>> list_objects(
     CollectionRef c,
     const ghobject_t& start,
     const ghobject_t& end,
     uint64_t limit) const final;
 
   /// Retrieves paged set of values > start (if present)
-  seastar::future<bool, omap_values_t> omap_get_values(
+  seastar::future<std::tuple<bool, omap_values_t>> omap_get_values(
     CollectionRef c,           ///< [in] collection
     const ghobject_t &oid,     ///< [in] oid
     const std::optional<std::string> &start ///< [in] start, empty for begin
@@ -129,7 +129,8 @@ public:
 
   seastar::future<> write_meta(const std::string& key,
 		  const std::string& value) final;
-  seastar::future<int, std::string> read_meta(const std::string& key) final;
+  seastar::future<std::tuple<int, std::string>>
+  read_meta(const std::string& key) final;
   uuid_d get_fsid() const final;
   unsigned get_max_attr_name_length() const final;
 
diff --git a/src/crimson/os/futurized_store.h b/src/crimson/os/futurized_store.h
index a47855d8c0b76..445f34ef4dcbb 100644
--- a/src/crimson/os/futurized_store.h
+++ b/src/crimson/os/futurized_store.h
@@ -122,12 +122,12 @@ public:
                                          CollectionRef c,
                                          const ghobject_t& oid,
                                          const omap_keys_t& keys) = 0;
-  virtual seastar::future<std::vector<ghobject_t>, ghobject_t> list_objects(
-                                         CollectionRef c,
-                                         const ghobject_t& start,
-                                         const ghobject_t& end,
-                                         uint64_t limit) const = 0;
-  virtual seastar::future<bool, omap_values_t> omap_get_values(
+  virtual seastar::future<std::tuple<std::vector<ghobject_t>, ghobject_t>> list_objects(
+    CollectionRef c,
+    const ghobject_t& start,
+    const ghobject_t& end,
+    uint64_t limit) const = 0;
+  virtual seastar::future<std::tuple<bool, omap_values_t>> omap_get_values(
     CollectionRef c,           ///< [in] collection
     const ghobject_t &oid,     ///< [in] oid
     const std::optional<std::string> &start ///< [in] start, empty for begin
@@ -154,7 +154,8 @@ public:
 
   virtual seastar::future<> write_meta(const std::string& key,
 				       const std::string& value) = 0;
-  virtual seastar::future<int, std::string> read_meta(const std::string& key) = 0;
+  virtual seastar::future<std::tuple<int, std::string>> read_meta(
+    const std::string& key) = 0;
   virtual uuid_d get_fsid() const  = 0;
   virtual unsigned get_max_attr_name_length() const = 0;
 };
diff --git a/src/crimson/osd/ops_executer.cc b/src/crimson/osd/ops_executer.cc
index 19a3292118c33..5d36f3ac8e4be 100644
--- a/src/crimson/osd/ops_executer.cc
+++ b/src/crimson/osd/ops_executer.cc
@@ -527,7 +527,8 @@ static seastar::future<ceph::bufferlist> do_pgnls_common(
   }
 
   return backend.list_objects(lower_bound, limit).then(
-    [&backend, filter, nspace](auto objects, auto next) {
+    [&backend, filter, nspace](auto&& ret) {
+      auto& [objects, next] = ret;
       auto in_my_namespace = [&nspace](const hobject_t& obj) {
         using crimson::common::local_conf;
         if (obj.get_namespace() == local_conf()->osd_hit_set_namespace) {
@@ -792,7 +793,8 @@ static seastar::future<ceph::bufferlist> do_pgls_common(
 
   using entries_t = decltype(pg_ls_response_t::entries);
   return backend.list_objects(lower_bound, limit).then(
-    [&backend, filter, nspace](auto objects, auto next) {
+    [&backend, filter, nspace](auto&& ret) {
+      auto& [objects, next] = ret;
       return seastar::when_all_succeed(
         seastar::map_reduce(std::move(objects),
           [&backend, filter, nspace](const hobject_t& obj) {
diff --git a/src/crimson/osd/osd.cc b/src/crimson/osd/osd.cc
index 65fc121587eff..538199ed03bbf 100644
--- a/src/crimson/osd/osd.cc
+++ b/src/crimson/osd/osd.cc
@@ -301,7 +301,8 @@ seastar::future<> OSD::start()
 seastar::future<> OSD::start_boot()
 {
   state.set_preboot();
-  return monc->get_version("osdmap").then([this](version_t newest, version_t oldest) {
+  return monc->get_version("osdmap").then([this](auto&& ret) {
+    auto [newest, oldest] = ret;
     return _preboot(oldest, newest);
   });
 }
@@ -385,7 +386,8 @@ seastar::future<> OSD::_add_me_to_crush()
       "args": [{}]
     }})", whoami, weight, loc);
     return monc->run_command({cmd}, {});
-  }).then([](int32_t code, string message, bufferlist) {
+  }).then([](auto&& command_result) {
+    [[maybe_unused]] auto [code, message, out] = std::move(command_result);
     if (code) {
       logger().warn("fail to add to crush: {} ({})", message, code);
       throw std::runtime_error("fail to add to crush");
@@ -517,10 +519,10 @@ seastar::future<Ref<PG>> OSD::make_pg(cached_map_t create_map,
       if (pi.is_erasure()) {
 	ec_profile = create_map->get_erasure_code_profile(pi.erasure_code_profile);
       }
-      return seastar::make_ready_future<pg_pool_t, string, ec_profile_t>(
-	std::move(pi),
-	std::move(name),
-	std::move(ec_profile));
+      return seastar::make_ready_future<std::tuple<pg_pool_t, string, ec_profile_t>>(
+        std::make_tuple(std::move(pi),
+			std::move(name),
+			std::move(ec_profile)));
     } else {
       // pool was deleted; grab final pg_pool_t off disk.
       return meta_coll->load_final_pool_info(pgid.pool());
@@ -770,7 +772,7 @@ seastar::future<Ref<PG>> OSD::handle_pg_create_info(
     [this](auto &info) -> seastar::future<Ref<PG>> {
       return get_map(info->epoch).then(
 	[&info, this](cached_map_t startmap) ->
-	seastar::future<Ref<PG>, cached_map_t> {
+	seastar::future<std::tuple<Ref<PG>, cached_map_t>> {
 	  const spg_t &pgid = info->pgid;
 	  if (info->by_mon) {
 	    int64_t pool_id = pgid.pgid.pool();
@@ -780,9 +782,8 @@ seastar::future<Ref<PG>> OSD::handle_pg_create_info(
 		"{} ignoring pgid {}, pool dne",
 		__func__,
 		pgid);
-	      return seastar::make_ready_future<Ref<PG>, cached_map_t>(
-		Ref<PG>(),
-		startmap);
+	      return seastar::make_ready_future<std::tuple<Ref<PG>, cached_map_t>>(
+                std::make_tuple(Ref<PG>(), startmap));
 	    }
 	    ceph_assert(osdmap->require_osd_release >= ceph_release_t::octopus);
 	    if (!pool->has_flag(pg_pool_t::FLAG_CREATING)) {
@@ -793,19 +794,18 @@ seastar::future<Ref<PG>> OSD::handle_pg_create_info(
 		"{} dropping {} create, pool does not have CREATING flag set",
 		__func__,
 		pgid);
-	      return seastar::make_ready_future<Ref<PG>, cached_map_t>(
-		Ref<PG>(),
-		startmap);
+	      return seastar::make_ready_future<std::tuple<Ref<PG>, cached_map_t>>(
+                std::make_tuple(Ref<PG>(), startmap));
 	    }
 	  }
 	  return make_pg(startmap, pgid, true).then(
 	    [startmap=std::move(startmap)](auto pg) mutable {
-	      return seastar::make_ready_future<Ref<PG>, cached_map_t>(
-		std::move(pg),
-		std::move(startmap));
+	      return seastar::make_ready_future<std::tuple<Ref<PG>, cached_map_t>>(
+                std::make_tuple(std::move(pg), std::move(startmap)));
 	    });
-      }).then([this, &info](auto pg, auto startmap) ->
+      }).then([this, &info](auto&& ret) ->
               seastar::future<Ref<PG>> {
+        auto [pg, startmap] = std::move(ret);
         if (!pg)
           return seastar::make_ready_future<Ref<PG>>(Ref<PG>());
         PeeringCtx rctx{ceph_release_t::octopus};
diff --git a/src/crimson/osd/osd_meta.cc b/src/crimson/osd/osd_meta.cc
index bd5880540be8f..ecb8e3ff7b533 100644
--- a/src/crimson/osd/osd_meta.cc
+++ b/src/crimson/osd/osd_meta.cc
@@ -56,9 +56,9 @@ seastar::future<OSDSuperblock> OSDMeta::load_superblock()
     }));
 }
 
-seastar::future<pg_pool_t,
-                std::string,
-                OSDMeta::ec_profile_t>
+seastar::future<std::tuple<pg_pool_t,
+			   std::string,
+			   OSDMeta::ec_profile_t>>
 OSDMeta::load_final_pool_info(int64_t pool) {
   return store->read(coll, final_pool_info_oid(pool),
                      0, 0).safe_then([this] (bufferlist&& bl) {
@@ -69,11 +69,12 @@ OSDMeta::load_final_pool_info(int64_t pool) {
     decode(pi, p);
     decode(name, p);
     decode(ec_profile, p);
-    return seastar::make_ready_future<pg_pool_t,
-                                      string,
-                                      ec_profile_t>(std::move(pi),
-                                                    std::move(name),
-                                                    std::move(ec_profile));
+    return seastar::make_ready_future<std::tuple<pg_pool_t,
+						 string,
+						 ec_profile_t>>(
+      std::make_tuple(std::move(pi),
+		      std::move(name),
+		      std::move(ec_profile)));
   },read_errorator::all_same_way([pool] {
     throw std::runtime_error(fmt::format("read gave enoent on {}",
                                          final_pool_info_oid(pool)));
diff --git a/src/crimson/osd/osd_meta.h b/src/crimson/osd/osd_meta.h
index e4043c768cd53..84157208754d1 100644
--- a/src/crimson/osd/osd_meta.h
+++ b/src/crimson/osd/osd_meta.h
@@ -46,9 +46,9 @@ public:
   seastar::future<OSDSuperblock> load_superblock();
 
   using ec_profile_t = std::map<std::string, std::string>;
-  seastar::future<pg_pool_t,
-                  std::string,
-                  ec_profile_t> load_final_pool_info(int64_t pool);
+  seastar::future<std::tuple<pg_pool_t,
+			     std::string,
+			     ec_profile_t>> load_final_pool_info(int64_t pool);
 private:
   static ghobject_t osdmap_oid(epoch_t epoch);
   static ghobject_t final_pool_info_oid(int64_t pool);
diff --git a/src/crimson/osd/pg_backend.cc b/src/crimson/osd/pg_backend.cc
index a308c41557c4c..0e67167d3ae14 100644
--- a/src/crimson/osd/pg_backend.cc
+++ b/src/crimson/osd/pg_backend.cc
@@ -374,7 +374,7 @@ seastar::future<> PGBackend::remove(ObjectState& os,
   return seastar::now();
 }
 
-seastar::future<std::vector<hobject_t>, hobject_t>
+seastar::future<std::tuple<std::vector<hobject_t>, hobject_t>>
 PGBackend::list_objects(const hobject_t& start, uint64_t limit) const
 {
   auto gstart = start.is_min() ? ghobject_t{} : ghobject_t{start, 0, shard};
@@ -382,7 +382,8 @@ PGBackend::list_objects(const hobject_t& start, uint64_t limit) const
                              gstart,
                              ghobject_t::get_max(),
                              limit)
-    .then([](std::vector<ghobject_t> gobjects, ghobject_t next) {
+    .then([](auto ret) {
+      auto& [gobjects, next] = ret;
       std::vector<hobject_t> objects;
       boost::copy(gobjects |
         boost::adaptors::filtered([](const ghobject_t& o) {
@@ -398,8 +399,8 @@ PGBackend::list_objects(const hobject_t& start, uint64_t limit) const
           return o.hobj;
         }),
         std::back_inserter(objects));
-      return seastar::make_ready_future<std::vector<hobject_t>, hobject_t>(
-        objects, next.hobj);
+      return seastar::make_ready_future<std::tuple<std::vector<hobject_t>, hobject_t>>(
+        std::make_tuple(objects, next.hobj));
     });
 }
 
@@ -482,7 +483,7 @@ maybe_get_omap_vals_by_keys(
   }
 }
 
-static seastar::future<bool, crimson::os::FuturizedStore::omap_values_t>
+static seastar::future<std::tuple<bool, crimson::os::FuturizedStore::omap_values_t>>
 maybe_get_omap_vals(
   crimson::os::FuturizedStore* store,
   const crimson::os::CollectionRef& coll,
@@ -492,8 +493,8 @@ maybe_get_omap_vals(
   if (oi.is_omap()) {
     return store->omap_get_values(coll, ghobject_t{oi.soid}, start_after);
   } else {
-    return seastar::make_ready_future<bool, crimson::os::FuturizedStore::omap_values_t>(
-      true, crimson::os::FuturizedStore::omap_values_t{});
+    return seastar::make_ready_future<std::tuple<bool, crimson::os::FuturizedStore::omap_values_t>>(
+      std::make_tuple(true, crimson::os::FuturizedStore::omap_values_t{}));
   }
 }
 
@@ -522,11 +523,11 @@ seastar::future<> PGBackend::omap_get_keys(
 
   // TODO: truly chunk the reading
   return maybe_get_omap_vals(store, coll, os.oi, start_after).then(
-    [=, &osd_op] (bool, crimson::os::FuturizedStore::omap_values_t vals) {
+    [=, &osd_op] (auto ret) {
       ceph::bufferlist result;
       bool truncated = false;
       uint32_t num = 0;
-      for (auto& [key, val] : vals) {
+      for (auto& [key, val] : std::get<1>(ret)) {
         if (num++ >= max_return ||
             result.length() >= local_conf()->osd_max_omap_bytes_per_request) {
           truncated = true;
@@ -566,8 +567,8 @@ seastar::future<> PGBackend::omap_get_vals(
 
   // TODO: truly chunk the reading
   return maybe_get_omap_vals(store, coll, os.oi, start_after).then(
-    [=, &osd_op] (const bool done,
-                  crimson::os::FuturizedStore::omap_values_t vals) {
+    [=, &osd_op] (auto&& ret) {
+      auto [done, vals] = std::move(ret);
       assert(done);
       ceph::bufferlist result;
       bool truncated = false;
diff --git a/src/crimson/osd/pg_backend.h b/src/crimson/osd/pg_backend.h
index 5753a2eb5edae..89ca0905869dd 100644
--- a/src/crimson/osd/pg_backend.h
+++ b/src/crimson/osd/pg_backend.h
@@ -91,7 +91,7 @@ public:
     epoch_t min_epoch,
     epoch_t map_epoch,
     std::vector<pg_log_entry_t>&& log_entries);
-  seastar::future<std::vector<hobject_t>, hobject_t> list_objects(
+  seastar::future<std::tuple<std::vector<hobject_t>, hobject_t>> list_objects(
     const hobject_t& start,
     uint64_t limit) const;
   seastar::future<> setxattr(
-- 
2.39.5