neorados: No dangling references in arguments

`async_initiate` may call its lambda after the containing function
returns. As such, reference arguments may no longer point to anything by
the time we use them.

Signed-off-by: Adam Emerson <aemerson@redhat.com>

diff --git a/src/include/neorados/RADOS.hpp b/src/include/neorados/RADOS.hpp
index 737d5da7e28c92f64a48bcf7c03d76cd3878d935..1b0443f30ccb40a9142d255b41243f19371f5306 100644 (file)
--- a/src/include/neorados/RADOS.hpp
+++ b/src/include/neorados/RADOS.hpp
@@ -525,7 +525,7 @@ public:
     template<typename CompletionToken>
     auto build(boost::asio::io_context& ioctx, CompletionToken&& token) {
       return boost::asio::async_initiate<CompletionToken, BuildSig>(
-       [&, this](auto&& handler) {
+       [&ioctx, this](auto&& handler) {
          build(ioctx, BuildComp::create(ioctx.get_executor(),
                                         std::move(handler)));
        }, token);
@@ -542,7 +542,7 @@ public:
                            boost::asio::io_context& ioctx,
                            CompletionToken&& token) {
     return boost::asio::async_initiate<CompletionToken, BuildSig>(
-      [&](auto&& handler) {
+      [cct, &ioctx](auto&& handler) {
        make_with_cct(cct, ioctx,
                      BuildComp::create(ioctx.get_executor(),
                                        std::move(handler)));
@@ -566,13 +566,14 @@ public:
   boost::asio::io_context& get_io_context();
 
   template<typename CompletionToken>
-  auto execute(const Object& o, const IOContext& ioc, ReadOp&& op,
+  auto execute(Object o, IOContext ioc, ReadOp op,
               ceph::buffer::list* bl,
               CompletionToken&& token, uint64_t* objver = nullptr,
               const blkin_trace_info* trace_info = nullptr) {
     return boost::asio::async_initiate<CompletionToken, Op::Signature>(
-      [&, this](auto&& handler) {
-       execute(o, ioc, std::move(op), bl,
+      [o = std::move(o), ioc = std::move(ioc), op = std::move(op),
+       bl, objver, trace_info, this](auto&& handler) mutable {
+       execute(std::move(o), std::move(ioc), std::move(op), bl,
                ReadOp::Completion::create(get_executor(),
                                           std::move(handler)),
                objver, trace_info);
@@ -580,12 +581,13 @@ public:
   }
 
   template<typename CompletionToken>
-  auto execute(const Object& o, const IOContext& ioc, WriteOp&& op,
+  auto execute(Object o, IOContext ioc, WriteOp op,
               CompletionToken&& token, uint64_t* objver = nullptr,
               const blkin_trace_info* trace_info = nullptr) {
     return boost::asio::async_initiate<CompletionToken, Op::Signature>(
-      [&, this](auto&& handler) {
-       execute(o, ioc, std::move(op),
+      [o = std::move(o), ioc = std::move(ioc), op = std::move(op),
+       objver, trace_info, this](auto&& handler) mutable {
+       execute(std::move(o), std::move(ioc), std::move(op),
                WriteOp::Completion::create(get_executor(),
                                            std::move(handler)),
                objver, trace_info);
@@ -598,12 +600,11 @@ public:
                             std::int64_t);
   using LookupPoolComp = ceph::async::Completion<LookupPoolSig>;
   template<typename CompletionToken>
-  auto lookup_pool(std::string_view name,
-                  CompletionToken&& token) {
+  auto lookup_pool(std::string name, CompletionToken&& token) {
     return boost::asio::async_initiate<CompletionToken, LookupPoolSig>(
-      [&, this](auto&& handler) {
-       lookup_pool(name, LookupPoolComp::create(get_executor(),
-                                                std::move(handler)));
+      [name = std::move(name), this](auto&& handler) mutable {
+       lookup_pool(std::move(name),
+                   LookupPoolComp::create(get_executor(), std::move(handler)));
       }, token);
   }
 
@@ -623,11 +624,11 @@ public:
   using SimpleOpSig = void(boost::system::error_code);
   using SimpleOpComp = ceph::async::Completion<SimpleOpSig>;
   template<typename CompletionToken>
-  auto create_pool_snap(int64_t pool, std::string_view snapName,
+  auto create_pool_snap(int64_t pool, std::string snap_name,
                        CompletionToken&& token) {
     return boost::asio::async_initiate<CompletionToken, SimpleOpSig>(
-      [&, this](auto&& handler) {
-       create_pool_snap(pool, snapName,
+      [snap_name = std::move(snap_name), pool, this](auto&& handler) mutable {
+       create_pool_snap(pool, std::move(snap_name),
                         SimpleOpComp::create(get_executor(),
                                              std::move(handler)));
       }, token);
@@ -636,10 +637,9 @@ public:
   using SMSnapSig = void(boost::system::error_code, std::uint64_t);
   using SMSnapComp = ceph::async::Completion<SMSnapSig>;
   template<typename CompletionToken>
-  auto allocate_selfmanaged_snap(int64_t pool,
-                                CompletionToken&& token) {
+  auto allocate_selfmanaged_snap(int64_t pool, CompletionToken&& token) {
     return boost::asio::async_initiate<CompletionToken, SMSnapSig>(
-      [&, this](auto&& handler) {
+      [pool, this](auto&& handler) {
        allocage_selfmanaged_snap(pool,
                                  SMSnapComp::create(get_executor(),
                                                     std::move(handler)));
@@ -647,54 +647,52 @@ public:
   }
 
   template<typename CompletionToken>
-  auto delete_pool_snap(int64_t pool, std::string_view snapName,
+  auto delete_pool_snap(int64_t pool, std::string snap_name,
                        CompletionToken&& token) {
     return boost::asio::async_initiate<CompletionToken, SimpleOpSig>(
-      [&, this](auto&& handler) {
-       delete_pool_snap(pool, snapName,
+      [snap_name = std::move(snap_name), pool, this](auto&& handler) mutable {
+       delete_pool_snap(pool, std::move(snap_name),
                         SimpleOpComp::create(get_executor(),
                                              std::move(handler)));
       }, token);
   }
 
   template<typename CompletionToken>
-  auto delete_selfmanaged_snap(int64_t pool, std::string_view snapName,
+  auto delete_selfmanaged_snap(int64_t pool, std::uint64_t snap,
                               CompletionToken&& token) {
     return boost::asio::async_initiate<CompletionToken, SimpleOpSig>(
-      [&, this](auto&& handler) {
-       delete_selfmanaged_snap(pool, snapName,
+      [snap, pool, this](auto&& handler) {
+       delete_selfmanaged_snap(pool, std::move(snap),
                                SimpleOpComp::create(get_executor(),
                                                     std::move(handler)));
       }, token);
   }
 
   template<typename CompletionToken>
-  auto create_pool(std::string_view name, std::optional<int> crush_rule,
+  auto create_pool(std::string name, std::optional<int> crush_rule,
                   CompletionToken&& token) {
     return boost::asio::async_initiate<CompletionToken, SimpleOpSig>(
-      [&, this](auto&& handler) {
-       create_pool(name, crush_rule,
+      [name = std::move(name), crush_rule, this](auto&& handler) mutable {
+       create_pool(std::move(name), crush_rule,
                    SimpleOpComp::create(get_executor(),
                                         std::move(handler)));
       }, token);
   }
 
   template<typename CompletionToken>
-  auto delete_pool(std::string_view name,
-                  CompletionToken&& token) {
+  auto delete_pool(std::string name, CompletionToken&& token) {
     return boost::asio::async_initiate<CompletionToken, SimpleOpSig>(
-      [&, this](auto&& handler) {
-       delete_pool(name,
+      [name = std::move(name), this](auto&& handler) mutable {
+       delete_pool(std::move(name),
                    SimpleOpComp::create(get_executor(),
                                         std::move(handler)));
       }, token);
   }
 
   template<typename CompletionToken>
-  auto delete_pool(int64_t pool,
-                  CompletionToken&& token) {
+  auto delete_pool(int64_t pool, CompletionToken&& token) {
     return boost::asio::async_initiate<CompletionToken, SimpleOpSig>(
-      [&, this](auto&& handler) {
+      [pool, this](auto&& handler) mutable {
        delete_pool(pool,
                    SimpleOpComp::create(get_executor(),
                                         std::move(handler)));
@@ -706,11 +704,10 @@ public:
                                                      PoolStats>, bool);
   using PoolStatComp = ceph::async::Completion<PoolStatSig>;
   template<typename CompletionToken>
-  auto stat_pools(const std::vector<std::string>& pools,
-                 CompletionToken&& token) {
+  auto stat_pools(std::vector<std::string> pools, CompletionToken&& token) {
     return boost::asio::async_initiate<CompletionToken, PoolStatSig>(
-      [&, this](auto&& handler) {
-       stat_pools(pools,
+      [pools = std::move(pools), this](auto&& handler) mutable {
+       stat_pools(std::move(pools),
                   PoolStatComp::create(get_executor(),
                                        std::move(handler)));
       }, token);
@@ -720,10 +717,9 @@ public:
                         FSStats);
   using StatFSComp = ceph::async::Completion<StatFSSig>;
   template<typename CompletionToken>
-  auto statfs(std::optional<int64_t> pool,
-             CompletionToken&& token) {
+  auto statfs(std::optional<int64_t> pool, CompletionToken&& token) {
     return boost::asio::async_initiate<CompletionToken, StatFSSig>(
-      [&, this](auto&& handler) {
+      [pool, this](auto&& handler) {
        statfs(pool, StatFSComp::create(get_executor(),
                                        std::move(handler)));
       }, token);
@@ -739,38 +735,40 @@ public:
                        uint64_t cookie);
   using WatchComp = ceph::async::Completion<WatchSig>;
   template<typename CompletionToken>
-  auto watch(const Object& o, const IOContext& ioc,
+  auto watch(Object o, IOContext ioc,
             std::optional<std::chrono::seconds> timeout,
-            WatchCB&& cb, CompletionToken&& token) {
+            WatchCB cb, CompletionToken&& token) {
     return boost::asio::async_initiate<CompletionToken, WatchSig>(
-      [&, this](auto&& handler) {
-       watch(o, ioc, timeout, cb, WatchComp::create(get_executor(),
-                                                    std::move(handler)));
+      [o = std::move(o), ioc = std::move(ioc), timeout,
+       cb = std::move(cb), this](auto&& handler) mutable {
+       watch(std::move(o), std::move(ioc), timeout, std::move(cb),
+             WatchComp::create(get_executor(), std::move(handler)));
       }, token);
   }
 
   template<typename CompletionToken>
-  auto notify_ack(const Object& o,
-                 const IOContext& ioc,
+  auto notify_ack(Object o, IOContext ioc,
                  uint64_t notify_id,
                  uint64_t cookie,
-                 ceph::buffer::list&& bl,
+                 ceph::buffer::list bl,
                  CompletionToken&& token) {
     return boost::asio::async_initiate<CompletionToken, SimpleOpSig>(
-      [&, this](auto&& handler) {
-       notify_ack(o, ioc, notify_id, cookie, std::move(bl),
+      [o = std::move(o), ioc = std::move(ioc), notify_id,
+       cookie, bl = std::move(bl), this](auto&& handler) mutable {
+       notify_ack(std::move(o), std::move(ioc), notify_id, cookie,
+                  std::move(bl),
                   SimpleOpComp::create(get_executor(),
                                        std::move(handler)));
       }, token);
   }
 
   template<typename CompletionToken>
-  auto unwatch(uint64_t cookie, const IOContext& ioc,
+  auto unwatch(uint64_t cookie, IOContext ioc,
               CompletionToken&& token) {
     return boost::asio::async_initiate<CompletionToken, SimpleOpSig>(
-      [&, this](auto&& handler) {
-       unwatch(cookie, ioc, SimpleOpComp::create(get_executor(),
-                                                 std::move(handler)));
+      [cookie, ioc = std::move(ioc), this](auto&& handler) mutable {
+       unwatch(cookie, std::move(ioc),
+               SimpleOpComp::create(get_executor(), std::move(handler)));
       }, token);
   }
 
@@ -792,12 +790,13 @@ public:
   using NotifySig = void(boost::system::error_code, ceph::buffer::list);
   using NotifyComp = ceph::async::Completion<NotifySig>;
   template<typename CompletionToken>
-  auto notify(const Object& oid, const IOContext& ioc, ceph::buffer::list&& bl,
+  auto notify(Object oid, IOContext ioc, ceph::buffer::list bl,
              std::optional<std::chrono::milliseconds> timeout,
              CompletionToken&& token) {
     return boost::asio::async_initiate<CompletionToken, NotifySig>(
-      [&, this](auto&& handler) {
-       notify(oid, ioc, std::move(bl), timeout,
+      [oid = std::move(oid), ioc = std::move(ioc),
+       bl = std::move(bl), timeout, this](auto&& handler) mutable {
+       notify(std::move(oid), std::move(ioc), std::move(bl), timeout,
               NotifyComp::create(get_executor(),
                                  std::move(handler)));
       }, token);
@@ -810,15 +809,17 @@ public:
                            Cursor);
   using EnumerateComp = ceph::async::Completion<EnumerateSig>;
   template<typename CompletionToken>
-  auto enumerate_objects(const IOContext& ioc, const Cursor& begin,
-                        const Cursor& end, const std::uint32_t max,
-                        const ceph::buffer::list& filter,
+  auto enumerate_objects(IOContext ioc, Cursor begin,
+                        Cursor end, std::uint32_t max,
+                        ceph::buffer::list filter,
                         CompletionToken&& token) {
     return boost::asio::async_initiate<CompletionToken, EnumerateSig>(
-      [&, this](auto&& handler) {
-       enumerate_objects(ioc, begin, end, max, filter,
+      [ioc = std::move(ioc), begin = std::move(begin), end = std::move(end),
+       max, filter = std::move(filter), this](auto&& handler) mutable {
+       enumerate_objects(std::move(ioc), std::move(begin), std::move(end),
+                         max, std::move(filter),
                          EnumerateComp::create(get_executor(),
-                                            std::move(handler)));
+                                               std::move(handler)));
       }, token);
   }
 
@@ -826,20 +827,22 @@ public:
                          std::string, ceph::buffer::list);
   using CommandComp = ceph::async::Completion<CommandSig>;
   template<typename CompletionToken>
-  auto osd_command(int osd, std::vector<std::string>&& cmd,
-                  ceph::buffer::list&& in, CompletionToken&& token) {
+  auto osd_command(int osd, std::vector<std::string> cmd,
+                  ceph::buffer::list in, CompletionToken&& token) {
     return boost::asio::async_initiate<CompletionToken, CommandSig>(
-      [&, this](auto&& handler) {
+      [osd, cmd = std::move(cmd), in = std::move(in),
+       this](auto&& handler) mutable {
        osd_command(osd, std::move(cmd), std::move(in),
                    CommandComp::create(get_executor(),
                                        std::move(handler)));
       }, token);
   }
   template<typename CompletionToken>
-  auto pg_command(PG pg, std::vector<std::string>&& cmd,
-                 ceph::buffer::list&& in, CompletionToken&& token) {
+  auto pg_command(PG pg, std::vector<std::string> cmd,
+                 ceph::buffer::list in, CompletionToken&& token) {
     return boost::asio::async_initiate<CompletionToken, CommandSig>(
-      [&, this](auto&& handler) {
+      [pg, cmd = std::move(cmd), in = std::move(in),
+       this](auto&& handler) mutable {
        pg_command(pg, std::move(cmd), std::move(in),
                   CommandComp::create(get_executor(),
                                       std::move(handler)));
@@ -847,36 +850,39 @@ public:
   }
 
   template<typename CompletionToken>
-  auto mon_command(const std::vector<std::string>& command,
-                  const ceph::buffer::list& bl,
+  auto mon_command(std::vector<std::string> command,
+                  ceph::buffer::list bl,
                   std::string* outs, ceph::buffer::list* outbl,
                   CompletionToken&& token) {
     return boost::asio::async_initiate<CompletionToken, SimpleOpSig>(
-      [&, this](auto&& handler) {
-       mon_command(command, bl, outs, outbl,
+      [command = std::move(command), bl = std::move(bl), outs,
+       outbl, this](auto&& handler) mutable {
+       mon_command(std::move(command), std::move(bl), outs, outbl,
                    SimpleOpComp::create(get_executor(),
                                         std::move(handler)));
       }, token);
   }
 
   template<typename CompletionToken>
-  auto enable_application(std::string_view pool, std::string_view app_name,
+  auto enable_application(std::string pool, std::string app_name,
                          bool force, CompletionToken&& token) {
     return boost::asio::async_initiate<CompletionToken, SimpleOpSig>(
-      [&, this](auto&& handler) {
-       enable_application(pool, app_name, force,
+      [pool = std::move(pool), app_name = std::move(app_name),
+       force, this](auto&& handler) mutable {
+       enable_application(std::move(pool), std::move(app_name), force,
                           SimpleOpComp::create(get_executor(),
                                                std::move(handler)));
       }, token);
   }
 
   template<typename CompletionToken>
-  auto blocklist_add(std::string_view client_address,
+  auto blocklist_add(std::string client_address,
                      std::optional<std::chrono::seconds> expire,
                      CompletionToken&& token) {
     return boost::asio::async_initiate<CompletionToken, SimpleOpSig>(
-      [&, this](auto&& handler) {
-       blocklist_add(client_address, expire,
+      [client_address = std::move(client_address), expire,
+       this](auto&& handler) mutable {
+       blocklist_add(std::move(client_address), expire,
                      SimpleOpComp::create(get_executor(),
                                           std::move(handler)));
       }, token);
@@ -904,77 +910,69 @@ private:
                            boost::asio::io_context& ioctx,
                    std::unique_ptr<BuildComp> c);
 
-  void execute(const Object& o, const IOContext& ioc, ReadOp&& op,
+  void execute(Object o, IOContext ioc, ReadOp op,
               ceph::buffer::list* bl, std::unique_ptr<Op::Completion> c,
               uint64_t* objver, const blkin_trace_info* trace_info);
 
-  void execute(const Object& o, const IOContext& ioc, WriteOp&& op,
+  void execute(Object o, IOContext ioc, WriteOp op,
               std::unique_ptr<Op::Completion> c, uint64_t* objver,
               const blkin_trace_info* trace_info);
 
-  void lookup_pool(std::string_view name, std::unique_ptr<LookupPoolComp> c);
+  void lookup_pool(std::string name, std::unique_ptr<LookupPoolComp> c);
   void list_pools(std::unique_ptr<LSPoolsComp> c);
-  void create_pool_snap(int64_t pool, std::string_view snapName,
+  void create_pool_snap(int64_t pool, std::string snap_name,
                        std::unique_ptr<SimpleOpComp> c);
   void allocate_selfmanaged_snap(int64_t pool, std::unique_ptr<SMSnapComp> c);
-  void delete_pool_snap(int64_t pool, std::string_view snapName,
+  void delete_pool_snap(int64_t pool, std::string snap_name,
                        std::unique_ptr<SimpleOpComp> c);
   void delete_selfmanaged_snap(int64_t pool, std::uint64_t snap,
                               std::unique_ptr<SimpleOpComp> c);
-  void create_pool(std::string_view name, std::optional<int> crush_rule,
-                  std::unique_ptr<SimpleOpComp> c);
-  void delete_pool(std::string_view name,
+  void create_pool(std::string name, std::optional<int> crush_rule,
                   std::unique_ptr<SimpleOpComp> c);
-  void delete_pool(int64_t pool,
+  void delete_pool(std::string name,
                   std::unique_ptr<SimpleOpComp> c);
-  void stat_pools(const std::vector<std::string>& pools,
+  void delete_pool(int64_t pool, std::unique_ptr<SimpleOpComp> c);
+  void stat_pools(std::vector<std::string> pools,
                  std::unique_ptr<PoolStatComp> c);
   void stat_fs(std::optional<std::int64_t> pool,
               std::unique_ptr<StatFSComp> c);
 
-  void watch(const Object& o, const IOContext& ioc,
+  void watch(Object o, IOContext ioc,
             std::optional<std::chrono::seconds> timeout,
-            WatchCB&& cb, std::unique_ptr<WatchComp> c);
+            WatchCB cb, std::unique_ptr<WatchComp> c);
   tl::expected<ceph::timespan, boost::system::error_code>
   watch_check(uint64_t cookie);
-  void notify_ack(const Object& o,
-                 const IOContext& _ioc,
+  void notify_ack(Object o, IOContext _ioc,
                  uint64_t notify_id,
                  uint64_t cookie,
-                 ceph::buffer::list&& bl,
+                 ceph::buffer::list bl,
                  std::unique_ptr<SimpleOpComp>);
-  void unwatch(uint64_t cookie, const IOContext& ioc,
+  void unwatch(uint64_t cookie, IOContext ioc,
               std::unique_ptr<SimpleOpComp>);
-  void notify(const Object& oid, const IOContext& ioctx,
-             ceph::buffer::list&& bl,
+  void notify(Object oid, IOContext ioctx,
+             ceph::buffer::list bl,
              std::optional<std::chrono::milliseconds> timeout,
              std::unique_ptr<NotifyComp> c);
   void flush_watch(std::unique_ptr<VoidOpComp>);
 
-  void enumerate_objects(const IOContext& ioc, const Cursor& begin,
-                        const Cursor& end, const std::uint32_t max,
-                        const ceph::buffer::list& filter,
-                        std::vector<Entry>* ls,
-                        Cursor* cursor,
-                        std::unique_ptr<SimpleOpComp> c);
-  void enumerate_objects(const IOContext& ioc, const Cursor& begin,
-                        const Cursor& end, const std::uint32_t max,
-                        const ceph::buffer::list& filter,
+  void enumerate_objects(IOContext ioc, Cursor begin,
+                        Cursor end, std::uint32_t max,
+                        ceph::buffer::list filter,
                         std::unique_ptr<EnumerateComp> c);
-  void osd_command(int osd, std::vector<std::string>&& cmd,
-                  ceph::buffer::list&& in, std::unique_ptr<CommandComp> c);
-  void pg_command(PG pg, std::vector<std::string>&& cmd,
-                 ceph::buffer::list&& in, std::unique_ptr<CommandComp> c);
+  void osd_command(int osd, std::vector<std::string> cmd,
+                  ceph::buffer::list in, std::unique_ptr<CommandComp> c);
+  void pg_command(PG pg, std::vector<std::string> cmd,
+                 ceph::buffer::list in, std::unique_ptr<CommandComp> c);
 
   void mon_command(std::vector<std::string> command,
-                  const ceph::buffer::list& bl,
+                  ceph::buffer::list bl,
                   std::string* outs, ceph::buffer::list* outbl,
                   std::unique_ptr<SimpleOpComp> c);
 
-  void enable_application(std::string_view pool, std::string_view app_name,
+  void enable_application(std::string pool, std::string app_name,
                          bool force, std::unique_ptr<SimpleOpComp> c);
 
-  void blocklist_add(std::string_view client_address,
+  void blocklist_add(std::string client_address,
                      std::optional<std::chrono::seconds> expire,
                      std::unique_ptr<SimpleOpComp> c);
 

diff --git a/src/neorados/RADOS.cc b/src/neorados/RADOS.cc
index c238ff450dc57914d092b3b3c6a6eb349e318de1..15b74f8e78d1c1ef90f82abd09c95bea8f67199e 100644 (file)
--- a/src/neorados/RADOS.cc
+++ b/src/neorados/RADOS.cc
@@ -796,7 +796,7 @@ boost::asio::io_context& RADOS::get_io_context() {
   return impl->ioctx;
 }
 
-void RADOS::execute(const Object& o, const IOContext& _ioc, ReadOp&& _op,
+void RADOS::execute(Object o, IOContext _ioc, ReadOp _op,
                    cb::list* bl,
                    std::unique_ptr<ReadOp::Completion> c, version_t* objver,
                    const blkin_trace_info *trace_info) {
@@ -819,7 +819,7 @@ void RADOS::execute(const Object& o, const IOContext& _ioc, ReadOp&& _op,
   trace.event("submitted");
 }
 
-void RADOS::execute(const Object& o, const IOContext& _ioc, WriteOp&& _op,
+void RADOS::execute(Object o, IOContext _ioc, WriteOp _op,
                    std::unique_ptr<WriteOp::Completion> c, version_t* objver,
                    const blkin_trace_info *trace_info) {
   auto oid = reinterpret_cast<const object_t*>(&o.impl);
@@ -851,8 +851,7 @@ boost::uuids::uuid RADOS::get_fsid() const noexcept {
 }
 
 
-void RADOS::lookup_pool(std::string_view name,
-                       std::unique_ptr<LookupPoolComp> c)
+void RADOS::lookup_pool(std::string name, std::unique_ptr<LookupPoolComp> c)
 {
   // I kind of want to make lookup_pg_pool return
   // std::optional<int64_t> since it can only return one error code.
@@ -861,9 +860,8 @@ void RADOS::lookup_pool(std::string_view name,
     name);
   if (ret < 0) {
     impl->objecter->wait_for_latest_osdmap(
-      [name = std::string(name), c = std::move(c),
-       objecter = impl->objecter]
-      (bs::error_code ec) mutable {
+      [name = std::move(name), c = std::move(c),
+       objecter = impl->objecter](bs::error_code ec) mutable {
        int64_t ret =
          objecter->with_osdmap([&](const OSDMap &osdmap) {
            return osdmap.lookup_pg_pool_name(name);
@@ -874,9 +872,6 @@ void RADOS::lookup_pool(std::string_view name,
        else
          ca::dispatch(std::move(c), bs::error_code{}, ret);
       });
-  } else if (ret < 0) {
-    ca::post(std::move(c), osdc_errc::pool_dne,
-                std::int64_t(0));
   } else {
     ca::post(std::move(c), bs::error_code{}, ret);
   }
@@ -912,11 +907,11 @@ void RADOS::list_pools(std::unique_ptr<LSPoolsComp> c) {
 }
 
 void RADOS::create_pool_snap(std::int64_t pool,
-                            std::string_view snapName,
+                            std::string snap_name,
                             std::unique_ptr<SimpleOpComp> c)
 {
   impl->objecter->create_pool_snap(
-    pool, snapName,
+    pool, snap_name,
     Objecter::PoolOp::OpComp::create(
       get_executor(),
       [c = std::move(c)](bs::error_code e, const bufferlist&) mutable {
@@ -936,11 +931,11 @@ void RADOS::allocate_selfmanaged_snap(int64_t pool,
 }
 
 void RADOS::delete_pool_snap(std::int64_t pool,
-                            std::string_view snapName,
+                            std::string snap_name,
                             std::unique_ptr<SimpleOpComp> c)
 {
   impl->objecter->delete_pool_snap(
-    pool, snapName,
+    pool, snap_name,
     Objecter::PoolOp::OpComp::create(
       get_executor(),
       [c = std::move(c)](bs::error_code e, const bufferlist&) mutable {
@@ -961,7 +956,7 @@ void RADOS::delete_selfmanaged_snap(std::int64_t pool,
       }));
 }
 
-void RADOS::create_pool(std::string_view name,
+void RADOS::create_pool(std::string name,
                        std::optional<int> crush_rule,
                        std::unique_ptr<SimpleOpComp> c)
 {
@@ -975,8 +970,7 @@ void RADOS::create_pool(std::string_view name,
       crush_rule.value_or(-1));
 }
 
-void RADOS::delete_pool(std::string_view name,
-                       std::unique_ptr<SimpleOpComp> c)
+void RADOS::delete_pool(std::string name, std::unique_ptr<SimpleOpComp> c)
 {
   impl->objecter->delete_pool(
     name,
@@ -999,7 +993,7 @@ void RADOS::delete_pool(std::int64_t pool,
       }));
 }
 
-void RADOS::stat_pools(const std::vector<std::string>& pools,
+void RADOS::stat_pools(std::vector<std::string> pools,
                       std::unique_ptr<PoolStatComp> c) {
   impl->objecter->get_pool_stats(
     pools,
@@ -1058,8 +1052,8 @@ void RADOS::stat_fs(std::optional<std::int64_t> _pool,
 
 // --- Watch/Notify
 
-void RADOS::watch(const Object& o, const IOContext& _ioc,
-                 std::optional<std::chrono::seconds> timeout, WatchCB&& cb,
+void RADOS::watch(Object o, IOContext _ioc,
+                 std::optional<std::chrono::seconds> timeout, WatchCB cb,
                  std::unique_ptr<WatchComp> c) {
   auto oid = reinterpret_cast<const object_t*>(&o.impl);
   auto ioc = reinterpret_cast<const IOContextImpl*>(&_ioc.impl);
@@ -1081,11 +1075,10 @@ void RADOS::watch(const Object& o, const IOContext& _ioc,
       }), nullptr);
 }
 
-void RADOS::notify_ack(const Object& o,
-                      const IOContext& _ioc,
+void RADOS::notify_ack(Object o, IOContext _ioc,
                       uint64_t notify_id,
                       uint64_t cookie,
-                      bufferlist&& bl,
+                      bufferlist bl,
                       std::unique_ptr<SimpleOpComp> c)
 {
   auto oid = reinterpret_cast<const object_t*>(&o.impl);
@@ -1104,7 +1097,7 @@ tl::expected<ceph::timespan, bs::error_code> RADOS::watch_check(uint64_t cookie)
   return impl->objecter->linger_check(linger_op);
 }
 
-void RADOS::unwatch(uint64_t cookie, const IOContext& _ioc,
+void RADOS::unwatch(uint64_t cookie, IOContext _ioc,
                    std::unique_ptr<SimpleOpComp> c)
 {
   auto ioc = reinterpret_cast<const IOContextImpl*>(&_ioc.impl);
@@ -1185,7 +1178,7 @@ struct NotifyHandler : std::enable_shared_from_this<NotifyHandler> {
   }
 };
 
-void RADOS::notify(const Object& o, const IOContext& _ioc, bufferlist&& bl,
+void RADOS::notify(Object o, IOContext _ioc, bufferlist bl,
                   std::optional<std::chrono::milliseconds> timeout,
                   std::unique_ptr<NotifyComp> c)
 {
@@ -1319,14 +1312,10 @@ Cursor::from_str(const std::string& s) {
   return e;
 }
 
-void RADOS::enumerate_objects(const IOContext& _ioc,
-                             const Cursor& begin,
-                             const Cursor& end,
-                             const std::uint32_t max,
-                             const bufferlist& filter,
+void RADOS::enumerate_objects(IOContext _ioc, Cursor begin, Cursor end,
+                             std::uint32_t max, ceph::buffer::list filter,
                              std::unique_ptr<EnumerateComp> c) {
   auto ioc = reinterpret_cast<const IOContextImpl*>(&_ioc.impl);
-
   impl->objecter->enumerate_objects<Entry>(
     ioc->oloc.pool,
     ioc->oloc.nspace,
@@ -1342,8 +1331,8 @@ void RADOS::enumerate_objects(const IOContext& _ioc,
     });
 }
 
-void RADOS::osd_command(int osd, std::vector<std::string>&& cmd,
-                       ceph::bufferlist&& in, std::unique_ptr<CommandComp> c) {
+void RADOS::osd_command(int osd, std::vector<std::string> cmd,
+                       ceph::buffer::list in, std::unique_ptr<CommandComp> c) {
   impl->objecter->osd_command(osd, std::move(cmd), std::move(in), nullptr,
                              [c = std::move(c)]
                              (bs::error_code ec,
@@ -1354,8 +1343,8 @@ void RADOS::osd_command(int osd, std::vector<std::string>&& cmd,
                                             std::move(b));
                              });
 }
-void RADOS::pg_command(PG pg, std::vector<std::string>&& cmd,
-                      ceph::bufferlist&& in, std::unique_ptr<CommandComp> c) {
+void RADOS::pg_command(PG pg, std::vector<std::string> cmd,
+                      ceph::buffer::list in, std::unique_ptr<CommandComp> c) {
   impl->objecter->pg_command(pg_t{pg.seed, pg.pool}, std::move(cmd), std::move(in), nullptr,
                             [c = std::move(c)]
                             (bs::error_code ec,
@@ -1367,7 +1356,7 @@ void RADOS::pg_command(PG pg, std::vector<std::string>&& cmd,
                             });
 }
 
-void RADOS::enable_application(std::string_view pool, std::string_view app_name,
+void RADOS::enable_application(std::string pool, std::string app_name,
                               bool force, std::unique_ptr<SimpleOpComp> c) {
   // pre-Luminous clusters will return -EINVAL and application won't be
   // preserved until Luminous is configured as minimum version.
@@ -1387,7 +1376,7 @@ void RADOS::enable_application(std::string_view pool, std::string_view app_name,
   }
 }
 
-void RADOS::blocklist_add(std::string_view client_address,
+void RADOS::blocklist_add(std::string client_address,
                           std::optional<std::chrono::seconds> expire,
                           std::unique_ptr<SimpleOpComp> c) {
   auto expire_arg = (expire ?
@@ -1425,8 +1414,7 @@ void RADOS::wait_for_latest_osd_map(std::unique_ptr<SimpleOpComp> c) {
 }
 
 void RADOS::mon_command(std::vector<std::string> command,
-                       const cb::list& bl,
-                       std::string* outs, cb::list* outbl,
+                       cb::list bl, std::string* outs, cb::list* outbl,
                        std::unique_ptr<SimpleOpComp> c) {
 
   impl->monclient.start_mon_command(

diff --git a/src/test/librados_test_stub/NeoradosTestStub.cc b/src/test/librados_test_stub/NeoradosTestStub.cc
index 6d3bd0de752771e8c0054d2c6fa272d8cca4d4c1..4b6866669fb1bef1e17a89dee31e5f3b51b48e31 100644 (file)
--- a/src/test/librados_test_stub/NeoradosTestStub.cc
+++ b/src/test/librados_test_stub/NeoradosTestStub.cc
@@ -133,6 +133,16 @@ Object::Object(std::string&& s) {
   new (&impl) object_t(std::move(s));
 }
 
+Object::Object(const Object& rhs) {
+  static_assert(impl_size >= sizeof(object_t));
+  new (&impl) object_t(*reinterpret_cast<const object_t*>(&rhs.impl));
+}
+
+Object::Object(Object&& rhs) {
+  static_assert(impl_size >= sizeof(object_t));
+  new (&impl) object_t(*std::move(reinterpret_cast<object_t*>(&rhs.impl)));
+}
+
 Object::~Object() {
   reinterpret_cast<object_t*>(&impl)->~object_t();
 }
@@ -157,6 +167,11 @@ IOContext::IOContext(const IOContext& rhs) {
   new (&impl) IOContextImpl(*reinterpret_cast<const IOContextImpl*>(&rhs.impl));
 }
 
+IOContext::IOContext(IOContext&& rhs) {
+  static_assert(impl_size >= sizeof(IOContextImpl));
+  new (&impl) IOContextImpl(std::move(*reinterpret_cast<const IOContextImpl*>(&rhs.impl)));
+}
+
 IOContext::IOContext(int64_t pool, std::string ns, std::string key)
   : IOContext() {
   set_pool(pool);
@@ -273,6 +288,15 @@ Op::Op() {
   o->get();
 }
 
+Op::Op(Op&& rhs) {
+  static_assert(Op::impl_size >= sizeof(librados::TestObjectOperationImpl*));
+  auto& o = *reinterpret_cast<librados::TestObjectOperationImpl**>(&impl);
+  auto& p = *reinterpret_cast<librados::TestObjectOperationImpl**>(&rhs.impl);
+  o = p;
+  p = new librados::TestObjectOperationImpl();
+  p->get();
+}
+
 Op::~Op() {
   auto& o = *reinterpret_cast<librados::TestObjectOperationImpl**>(&impl);
   if (o != nullptr) {
@@ -533,7 +557,7 @@ boost::asio::io_context::executor_type neorados::RADOS::get_executor() const {
   return impl->io_context.get_executor();
 }
 
-void RADOS::execute(const Object& o, const IOContext& ioc, ReadOp&& op,
+void RADOS::execute(Object o, IOContext ioc, ReadOp op,
                     ceph::buffer::list* bl, std::unique_ptr<Op::Completion> c,
                     uint64_t* objver, const blkin_trace_info* trace_info) {
   auto io_ctx = impl->get_io_ctx(ioc);
@@ -552,7 +576,7 @@ void RADOS::execute(const Object& o, const IOContext& ioc, ReadOp&& op,
   ceph_assert(r == 0);
 }
 
-void RADOS::execute(const Object& o, const IOContext& ioc, WriteOp&& op,
+void RADOS::execute(Object o, IOContext ioc, WriteOp op,
                     std::unique_ptr<Op::Completion> c, uint64_t* objver,
                     const blkin_trace_info* trace_info) {
   auto io_ctx = impl->get_io_ctx(ioc);
@@ -576,7 +600,7 @@ void RADOS::execute(const Object& o, const IOContext& ioc, WriteOp&& op,
 }
 
 void RADOS::mon_command(std::vector<std::string> command,
-                        const bufferlist& bl,
+                        bufferlist bl,
                         std::string* outs, bufferlist* outbl,
                         std::unique_ptr<Op::Completion> c) {
   auto r = impl->test_rados_client->mon_command(command, bl, outbl, outs);
@@ -584,7 +608,7 @@ void RADOS::mon_command(std::vector<std::string> command,
           (r < 0 ? bs::error_code(-r, osd_category()) : bs::error_code()));
 }
 
-void RADOS::blocklist_add(std::string_view client_address,
+void RADOS::blocklist_add(std::string client_address,
                           std::optional<std::chrono::seconds> expire,
                           std::unique_ptr<SimpleOpComp> c) {
   auto r = impl->test_rados_client->blocklist_add(