crimson: capture "this" explicitly

to silence warnings like:

```
alien_store.cc:577:64: warning: implicit capture of ‘this’ via ‘[=]’ is
deprecated in C++20 [-Wdeprecated]
  577 |     return tp->submit(ch->get_cid().hash_to_shard(tp->size()),
      [=, &bl] {
      |                                                                ^
```

Signed-off-by: Kefu Chai <tchaikov@gmail.com>

diff --git a/src/crimson/os/alienstore/alien_store.cc b/src/crimson/os/alienstore/alien_store.cc
index b3c2ec4a431600c09e0f7d743842f590c624d350..3df7a65677645009f3913f9a89e8db691ffd8371 100644 (file)
--- a/src/crimson/os/alienstore/alien_store.cc
+++ b/src/crimson/os/alienstore/alien_store.cc
@@ -201,10 +201,10 @@ AlienStore::list_objects(CollectionRef ch,
   logger().debug("{}", __func__);
   assert(tp);
   return do_with_op_gate(std::vector<ghobject_t>(), ghobject_t(),
-                         [=] (auto &objects, auto &next) {
+                         [=, this] (auto &objects, auto &next) {
     objects.reserve(limit);
     return tp->submit(ch->get_cid().hash_to_shard(tp->size()),
-      [=, &objects, &next] {
+      [=, this, &objects, &next] {
       auto c = static_cast<AlienCollection*>(ch.get());
       return store->collection_list(c->collection, start, end,
                                     store->get_ideal_list_max(),
@@ -273,7 +273,7 @@ seastar::future<std::vector<coll_t>> AlienStore::list_collections()
   logger().debug("{}", __func__);
   assert(tp);
 
-  return do_with_op_gate(std::vector<coll_t>{}, [=] (auto &ls) {
+  return do_with_op_gate(std::vector<coll_t>{}, [this] (auto &ls) {
     return tp->submit([this, &ls] {
       return store->list_collections(ls);
     }).then([&ls] (int r) {
@@ -292,8 +292,8 @@ AlienStore::read(CollectionRef ch,
 {
   logger().debug("{}", __func__);
   assert(tp);
-  return do_with_op_gate(ceph::bufferlist{}, [=] (auto &bl) {
-    return tp->submit(ch->get_cid().hash_to_shard(tp->size()), [=, &bl] {
+  return do_with_op_gate(ceph::bufferlist{}, [=, this] (auto &bl) {
+    return tp->submit(ch->get_cid().hash_to_shard(tp->size()), [=, this, &bl] {
       auto c = static_cast<AlienCollection*>(ch.get());
       return store->read(c->collection, oid, offset, len, bl, op_flags);
     }).then([&bl] (int r) -> read_errorator::future<ceph::bufferlist> {
@@ -344,8 +344,8 @@ AlienStore::get_attr(CollectionRef ch,
   logger().debug("{}", __func__);
   assert(tp);
   return do_with_op_gate(ceph::bufferlist{}, std::string{name},
-                         [=] (auto &value, const auto& name) {
-    return tp->submit(ch->get_cid().hash_to_shard(tp->size()), [=, &value, &name] {
+                         [=, this] (auto &value, const auto& name) {
+    return tp->submit(ch->get_cid().hash_to_shard(tp->size()), [=, this, &value, &name] {
       // XXX: `name` isn't a `std::string_view` anymore! it had to be converted
       // to `std::string` for the sake of extending life-time not only of
       // a _ptr-to-data_ but _data_ as well. Otherwise we would run into a use-
@@ -371,8 +371,8 @@ AlienStore::get_attrs(CollectionRef ch,
 {
   logger().debug("{}", __func__);
   assert(tp);
-  return do_with_op_gate(attrs_t{}, [=] (auto &aset) {
-    return tp->submit(ch->get_cid().hash_to_shard(tp->size()), [=, &aset] {
+  return do_with_op_gate(attrs_t{}, [=, this] (auto &aset) {
+    return tp->submit(ch->get_cid().hash_to_shard(tp->size()), [=, this, &aset] {
       auto c = static_cast<AlienCollection*>(ch.get());
       const auto r = store->getattrs(c->collection, oid, aset);
       return r;
@@ -393,8 +393,8 @@ auto AlienStore::omap_get_values(CollectionRef ch,
 {
   logger().debug("{}", __func__);
   assert(tp);
-  return do_with_op_gate(omap_values_t{}, [=] (auto &values) {
-    return tp->submit(ch->get_cid().hash_to_shard(tp->size()), [=, &values] {
+  return do_with_op_gate(omap_values_t{}, [=, this] (auto &values) {
+    return tp->submit(ch->get_cid().hash_to_shard(tp->size()), [=, this, &values] {
       auto c = static_cast<AlienCollection*>(ch.get());
       return store->omap_get_values(c->collection, oid, keys,
                                    reinterpret_cast<map<string, bufferlist>*>(&values));
@@ -417,8 +417,8 @@ auto AlienStore::omap_get_values(CollectionRef ch,
 {
   logger().debug("{} with_start", __func__);
   assert(tp);
-  return do_with_op_gate(omap_values_t{}, [=] (auto &values) {
-    return tp->submit(ch->get_cid().hash_to_shard(tp->size()), [=, &values] {
+  return do_with_op_gate(omap_values_t{}, [=, this] (auto &values) {
+    return tp->submit(ch->get_cid().hash_to_shard(tp->size()), [=, this, &values] {
       auto c = static_cast<AlienCollection*>(ch.get());
       return store->omap_get_values(c->collection, oid, start,
                                    reinterpret_cast<map<string, bufferlist>*>(&values));
@@ -471,8 +471,8 @@ seastar::future<> AlienStore::inject_data_error(const ghobject_t& o)
 {
   logger().debug("{}", __func__);
   assert(tp);
-  return seastar::with_gate(op_gate, [=] {
-    return tp->submit([=] {
+  return seastar::with_gate(op_gate, [=, this] {
+    return tp->submit([o, this] {
       return store->inject_data_error(o);
     });
   });
@@ -482,8 +482,8 @@ seastar::future<> AlienStore::inject_mdata_error(const ghobject_t& o)
 {
   logger().debug("{}", __func__);
   assert(tp);
-  return seastar::with_gate(op_gate, [=] {
-    return tp->submit([=] {
+  return seastar::with_gate(op_gate, [=, this] {
+    return tp->submit([=, this] {
       return store->inject_mdata_error(o);
     });
   });
@@ -494,8 +494,8 @@ seastar::future<> AlienStore::write_meta(const std::string& key,
 {
   logger().debug("{}", __func__);
   assert(tp);
-  return seastar::with_gate(op_gate, [=] {
-    return tp->submit([=] {
+  return seastar::with_gate(op_gate, [=, this] {
+    return tp->submit([=, this] {
       return store->write_meta(key, value);
     }).then([] (int r) {
       assert(r == 0);
@@ -573,8 +573,8 @@ auto AlienStore::omap_get_header(CollectionRef ch,
   -> get_attr_errorator::future<ceph::bufferlist>
 {
   assert(tp);
-  return do_with_op_gate(ceph::bufferlist(), [=](auto& bl) {
-    return tp->submit(ch->get_cid().hash_to_shard(tp->size()), [=, &bl] {
+  return do_with_op_gate(ceph::bufferlist(), [=, this](auto& bl) {
+    return tp->submit(ch->get_cid().hash_to_shard(tp->size()), [=, this, &bl] {
       auto c = static_cast<AlienCollection*>(ch.get());
       return store->omap_get_header(c->collection, oid, &bl);
     }).then([&bl](int r) -> get_attr_errorator::future<ceph::bufferlist> {
@@ -598,8 +598,8 @@ AlienStore::read_errorator::future<std::map<uint64_t, uint64_t>> AlienStore::fie
   uint64_t len)
 {
   assert(tp);
-  return do_with_op_gate(std::map<uint64_t, uint64_t>(), [=](auto& destmap) {
-    return tp->submit(ch->get_cid().hash_to_shard(tp->size()), [=, &destmap] {
+  return do_with_op_gate(std::map<uint64_t, uint64_t>(), [=, this](auto& destmap) {
+    return tp->submit(ch->get_cid().hash_to_shard(tp->size()), [=, this, &destmap] {
       auto c = static_cast<AlienCollection*>(ch.get());
       return store->fiemap(c->collection, oid, off, len, destmap);
     }).then([&destmap](int r)

diff --git a/src/crimson/os/cyanstore/cyan_store.cc b/src/crimson/os/cyanstore/cyan_store.cc
index f95412c175beb4ad3ab948f64109970094184228..4195e68e987c32c16e7f357538bc916dfd624bdb 100644 (file)
--- a/src/crimson/os/cyanstore/cyan_store.cc
+++ b/src/crimson/os/cyanstore/cyan_store.cc
@@ -107,7 +107,7 @@ CyanStore::mkfs_ertr::future<> CyanStore::mkfs(uuid_d new_osd_fsid)
   static const char read_meta_errmsg[]{"read_meta"};
   static const char parse_fsid_errmsg[]{"failed to parse fsid"};
   static const char match_ofsid_errmsg[]{"unmatched osd_fsid"};
-  return read_meta("fsid").then([=](auto&& ret) -> mkfs_ertr::future<> {
+  return read_meta("fsid").then([=, this](auto&& ret) -> mkfs_ertr::future<> {
     auto& [r, fsid_str] = ret;
     if (r == -ENOENT) {
       if (new_osd_fsid.is_zero()) {

diff --git a/src/crimson/os/seastore/btree/fixed_kv_btree.h b/src/crimson/os/seastore/btree/fixed_kv_btree.h
index 25be1bb9c2ae9d5e7d84a633882cb2a1456eaec1..3c514adaa99047c0c0c0412d2668dd0450f28f1d 100644 (file)
--- a/src/crimson/os/seastore/btree/fixed_kv_btree.h
+++ b/src/crimson/os/seastore/btree/fixed_kv_btree.h
@@ -888,7 +888,7 @@ public:
 
     return lower_bound(
       c, laddr
-    ).si_then([=](auto iter) {
+    ).si_then([=, this](auto iter) {
       assert(iter.get_depth() >= depth);
       if (depth == iter.get_depth()) {
         SUBTRACET(seastore_fixedkv_tree, "update at root", c.trans);

diff --git a/src/crimson/os/seastore/cache.cc b/src/crimson/os/seastore/cache.cc
index 88e4a6b2e9a12e1570943d76f267f0ae87ea1727..5db3654bb8c86e80c038117c20299f76a5508edf 100644 (file)
--- a/src/crimson/os/seastore/cache.cc
+++ b/src/crimson/os/seastore/cache.cc
@@ -1733,7 +1733,7 @@ Cache::replay_delta(
        "Invalid error in Cache::replay_delta"
       }
     );
-    return extent_fut.safe_then([=, &delta](auto extent) {
+    return extent_fut.safe_then([=, this, &delta](auto extent) {
       if (!extent) {
        DEBUG("replay extent is not present, so delta is obsolete at {} {} -- {}",
              journal_seq, record_base, delta);
@@ -1877,7 +1877,7 @@ Cache::get_extent_ertr::future<CachedExtentRef> Cache::_get_extent_by_type(
   extent_init_func_t &&extent_init_func,
   extent_init_func_t &&on_cache)
 {
-  return [=, extent_init_func=std::move(extent_init_func)]() mutable {
+  return [=, this, extent_init_func=std::move(extent_init_func)]() mutable {
     src_ext_t* p_metric_key = nullptr;
     src_ext_t metric_key;
     if (p_src) {

diff --git a/src/crimson/os/seastore/collection_manager/flat_collection_manager.cc b/src/crimson/os/seastore/collection_manager/flat_collection_manager.cc
index 7b0cb1f9c907f4d58686ea99e10323b76feeb1c7..5b3d5bc1fe70a20be6e0f814ea187222aae72f19 100644 (file)
--- a/src/crimson/os/seastore/collection_manager/flat_collection_manager.cc
+++ b/src/crimson/os/seastore/collection_manager/flat_collection_manager.cc
@@ -62,10 +62,10 @@ FlatCollectionManager::create(coll_root_t &coll_root, Transaction &t,
 {
   logger().debug("FlatCollectionManager: {}", __func__);
   return get_coll_root(coll_root, t
-  ).si_then([=, &coll_root, &t] (auto &&extent) {
+  ).si_then([=, this, &coll_root, &t] (auto &&extent) {
     return extent->create(
       get_coll_context(t), cid, info.split_bits
-    ).si_then([=, &coll_root, &t] (auto ret) {
+    ).si_then([=, this, &coll_root, &t] (auto ret) {
       switch (ret) {
       case CollectionNode::create_result_t::OVERFLOW: {
         logger().debug("FlatCollectionManager: {} overflow!", __func__);
@@ -76,14 +76,14 @@ FlatCollectionManager::create(coll_root_t &coll_root, Transaction &t,
        assert(new_size < MAX_FLAT_BLOCK_SIZE);
         return tm.alloc_extent<CollectionNode>(
          t, L_ADDR_MIN, new_size
-       ).si_then([=, &coll_root, &t] (auto &&root_extent) {
+       ).si_then([=, this, &coll_root, &t] (auto &&root_extent) {
           coll_root.update(root_extent->get_laddr(), root_extent->get_length());
 
          root_extent->decoded = extent->decoded;
          root_extent->loaded = true;
          return root_extent->create(
            get_coll_context(t), cid, info.split_bits
-         ).si_then([=, &t](auto result) {
+         ).si_then([=, this, &t](auto result) {
            assert(result == CollectionNode::create_result_t::SUCCESS);
            return tm.dec_ref(t, extent->get_laddr());
          }).si_then([] (auto) {

diff --git a/src/crimson/os/seastore/omap_manager/btree/omap_btree_node_impl.cc b/src/crimson/os/seastore/omap_manager/btree/omap_btree_node_impl.cc
index 0f4405bf5c685f328f12ac76ebfa56e48cf3e98c..16d13c6e5307d2aa16d2ec6fd8aa732e7e2541a8 100644 (file)
--- a/src/crimson/os/seastore/omap_manager/btree/omap_btree_node_impl.cc
+++ b/src/crimson/os/seastore/omap_manager/btree/omap_btree_node_impl.cc
@@ -361,7 +361,7 @@ OMapInnerNode::merge_entry(
   auto is_left = (iter + 1) == iter_cend();
   auto donor_iter = is_left ? iter - 1 : iter + 1;
   return omap_load_extent(oc, donor_iter->get_val(), get_meta().depth - 1)
-    .si_then([=] (auto &&donor) mutable {
+    .si_then([=, this] (auto &&donor) mutable {
     LOG_PREFIX(OMapInnerNode::merge_entry);
     auto [l, r] = is_left ?
       std::make_pair(donor, entry) : std::make_pair(entry, donor);

diff --git a/src/crimson/os/seastore/random_block_manager/nvme_block_device.cc b/src/crimson/os/seastore/random_block_manager/nvme_block_device.cc
index b6ab479abd1860b120e2304917ae40a882d03842..42541356c5ad86d232bd28fa1650819cbebede34 100644 (file)
--- a/src/crimson/os/seastore/random_block_manager/nvme_block_device.cc
+++ b/src/crimson/os/seastore/random_block_manager/nvme_block_device.cc
@@ -27,7 +27,7 @@ open_ertr::future<> NVMeBlockDevice::open(
   return seastar::do_with(in_path, [this, mode](auto& in_path) {
     return seastar::file_stat(in_path).then([this, mode, in_path](auto stat) {
       size = stat.size;
-      return seastar::open_file_dma(in_path, mode).then([=](auto file) {
+      return seastar::open_file_dma(in_path, mode).then([=, this](auto file) {
         device = file;
         logger().debug("open");
         // Get SSD's features from identify_controller and namespace command.
@@ -67,7 +67,7 @@ open_ertr::future<> NVMeBlockDevice::open_for_io(
   const std::string& in_path,
   seastar::open_flags mode) {
   io_device.resize(stream_id_count);
-  return seastar::do_for_each(io_device, [=](auto &target_device) {
+  return seastar::do_for_each(io_device, [=, this](auto &target_device) {
     return seastar::open_file_dma(in_path, mode).then([this](
       auto file) {
       io_device[stream_index_to_open] = file;

diff --git a/src/crimson/os/seastore/seastore.cc b/src/crimson/os/seastore/seastore.cc
index 38878ea4386089bbcd51aca9fecee7c596a6f404..c02b00d977fb7e8a8eb8f21f7ad225f083a14fee 100644 (file)
--- a/src/crimson/os/seastore/seastore.cc
+++ b/src/crimson/os/seastore/seastore.cc
@@ -644,7 +644,7 @@ SeaStore::read_errorator::future<ceph::bufferlist> SeaStore::read(
     Transaction::src_t::READ,
     "read_obj",
     op_type_t::READ,
-    [=](auto &t, auto &onode) -> ObjectDataHandler::read_ret {
+    [=, this](auto &t, auto &onode) -> ObjectDataHandler::read_ret {
       size_t size = onode.get_layout().size;
 
       if (offset >= size) {
@@ -675,10 +675,10 @@ SeaStore::read_errorator::future<ceph::bufferlist> SeaStore::readv(
   return seastar::do_with(
     _oid,
     ceph::bufferlist{},
-    [=, &m](auto &oid, auto &ret) {
+    [=, this, &m](auto &oid, auto &ret) {
     return crimson::do_for_each(
       m,
-      [=, &oid, &ret](auto &p) {
+      [=, this, &oid, &ret](auto &p) {
       return read(
        ch, oid, p.first, p.second, op_flags
        ).safe_then([&ret](auto bl) {
@@ -708,7 +708,7 @@ SeaStore::get_attr_errorator::future<ceph::bufferlist> SeaStore::get_attr(
     Transaction::src_t::READ,
     "get_attr",
     op_type_t::GET_ATTR,
-    [=](auto &t, auto& onode) -> _omap_get_value_ret {
+    [=, this](auto &t, auto& onode) -> _omap_get_value_ret {
       auto& layout = onode.get_layout();
       if (name == OI_ATTR && layout.oi_size) {
         ceph::bufferlist bl;
@@ -745,7 +745,7 @@ SeaStore::get_attrs_ertr::future<SeaStore::attrs_t> SeaStore::get_attrs(
     Transaction::src_t::READ,
     "get_addrs",
     op_type_t::GET_ATTRS,
-    [=](auto &t, auto& onode) {
+    [=, this](auto &t, auto& onode) {
       auto& layout = onode.get_layout();
       return _omap_list(onode, layout.xattr_root, t, std::nullopt,
         OMapManager::omap_list_config_t::with_inclusive(false)
@@ -781,7 +781,7 @@ seastar::future<struct stat> SeaStore::stat(
     Transaction::src_t::READ,
     "stat",
     op_type_t::STAT,
-    [=, &oid](auto &t, auto &onode) {
+    [=, this, &oid](auto &t, auto &onode) {
       struct stat st;
       auto &olayout = onode.get_layout();
       st.st_size = olayout.size;
@@ -1065,7 +1065,7 @@ SeaStore::_fiemap_ret SeaStore::_fiemap(
 {
   return seastar::do_with(
     ObjectDataHandler(max_object_size),
-    [=, &t, &onode] (auto &objhandler) {
+    [=, this, &t, &onode] (auto &objhandler) {
     return objhandler.fiemap(
       ObjectDataHandler::context_t{
         *transaction_manager,
@@ -1091,7 +1091,7 @@ SeaStore::read_errorator::future<std::map<uint64_t, uint64_t>> SeaStore::fiemap(
     Transaction::src_t::READ,
     "fiemap_read",
     op_type_t::READ,
-    [=](auto &t, auto &onode) -> _fiemap_ret {
+    [=, this](auto &t, auto &onode) -> _fiemap_ret {
     size_t size = onode.get_layout().size;
     if (off >= size) {
       INFOT("fiemap offset is over onode size!", t);
@@ -1400,7 +1400,7 @@ SeaStore::tm_ret SeaStore::_write(
   return seastar::do_with(
     std::move(_bl),
     ObjectDataHandler(max_object_size),
-    [=, &ctx, &onode](auto &bl, auto &objhandler) {
+    [=, this, &ctx, &onode](auto &bl, auto &objhandler) {
       return objhandler.write(
         ObjectDataHandler::context_t{
           *transaction_manager,
@@ -1427,7 +1427,7 @@ SeaStore::tm_ret SeaStore::_zero(
   object_size = std::max<uint64_t>(offset + len, object_size);
   return seastar::do_with(
     ObjectDataHandler(max_object_size),
-    [=, &ctx, &onode](auto &objhandler) {
+    [=, this, &ctx, &onode](auto &objhandler) {
       return objhandler.zero(
         ObjectDataHandler::context_t{
           *transaction_manager,
@@ -1597,7 +1597,7 @@ SeaStore::tm_ret SeaStore::_truncate(
   onode->get_mutable_layout(*ctx.transaction).size = size;
   return seastar::do_with(
     ObjectDataHandler(max_object_size),
-    [=, &ctx, &onode](auto &objhandler) {
+    [=, this, &ctx, &onode](auto &objhandler) {
     return objhandler.truncate(
       ObjectDataHandler::context_t{
         *transaction_manager,
@@ -1758,16 +1758,16 @@ SeaStore::tm_ret SeaStore::_create_collection(
 {
   return transaction_manager->read_collection_root(
     *ctx.transaction
-  ).si_then([=, &ctx](auto _cmroot) {
+  ).si_then([=, this, &ctx](auto _cmroot) {
     return seastar::do_with(
       _cmroot,
-      [=, &ctx](auto &cmroot) {
+      [=, this, &ctx](auto &cmroot) {
         return collection_manager->create(
           cmroot,
           *ctx.transaction,
           cid,
           bits
-        ).si_then([=, &ctx, &cmroot] {
+        ).si_then([this, &ctx, &cmroot] {
           if (cmroot.must_update()) {
             transaction_manager->write_collection_root(
               *ctx.transaction,
@@ -1790,15 +1790,15 @@ SeaStore::tm_ret SeaStore::_remove_collection(
 {
   return transaction_manager->read_collection_root(
     *ctx.transaction
-  ).si_then([=, &ctx](auto _cmroot) {
+  ).si_then([=, this, &ctx](auto _cmroot) {
     return seastar::do_with(
       _cmroot,
-      [=, &ctx](auto &cmroot) {
+      [=, this, &ctx](auto &cmroot) {
         return collection_manager->remove(
           cmroot,
           *ctx.transaction,
           cid
-        ).si_then([=, &ctx, &cmroot] {
+        ).si_then([this, &ctx, &cmroot] {
           // param here denotes whether it already existed, probably error
           if (cmroot.must_update()) {
             transaction_manager->write_collection_root(

diff --git a/src/crimson/os/seastore/segment_manager/block.cc b/src/crimson/os/seastore/segment_manager/block.cc
index 4435c45151a33869fba0205526cdf2f0659e24a0..e25feadc72bbdeb462ef8a47a78a2d90235f7781 100644 (file)
--- a/src/crimson/os/seastore/segment_manager/block.cc
+++ b/src/crimson/os/seastore/segment_manager/block.cc
@@ -466,11 +466,11 @@ BlockSegmentManager::mount_ret BlockSegmentManager::mount()
   LOG_PREFIX(BlockSegmentManager::mount);
   return open_device(
     device_path
-  ).safe_then([=](auto p) {
+  ).safe_then([=, this](auto p) {
     device = std::move(p.first);
     auto sd = p.second;
     return read_superblock(device, sd);
-  }).safe_then([=](auto sb) {
+  }).safe_then([=, this](auto sb) {
     set_device_id(sb.config.spec.id);
     INFO("{} read {}", device_id_printer_t{get_device_id()}, sb);
     sb.validate();
@@ -513,7 +513,7 @@ BlockSegmentManager::mkfs_ret BlockSegmentManager::mkfs(
     seastar::stat_data{},
     block_sm_superblock_t{},
     std::unique_ptr<SegmentStateTracker>(),
-    [=](auto &device, auto &stat, auto &sb, auto &tracker)
+    [=, this](auto &device, auto &stat, auto &sb, auto &tracker)
   {
     check_create_device_ret maybe_create = check_create_device_ertr::now();
     using crimson::common::get_conf;

diff --git a/src/crimson/os/seastore/transaction_manager.cc b/src/crimson/os/seastore/transaction_manager.cc
index 91cd17d0e623142eccb3d6bc8dd1bee5be882f01..81c79524a3b5774915f75e8aed88945fdb33a5cd 100644 (file)
--- a/src/crimson/os/seastore/transaction_manager.cc
+++ b/src/crimson/os/seastore/transaction_manager.cc
@@ -580,14 +580,14 @@ TransactionManager::get_extents_if_live_ret TransactionManager::get_extents_if_l
        t,
        laddr,
        len
-      ).si_then([=, &t](lba_pin_list_t pin_list) {
+      ).si_then([=, this, &t](lba_pin_list_t pin_list) {
        return seastar::do_with(
          std::list<CachedExtentRef>(),
          std::move(pin_list),
-         [=, &t](std::list<CachedExtentRef> &list, lba_pin_list_t &pin_list) {
+         [=, this, &t](std::list<CachedExtentRef> &list, lba_pin_list_t &pin_list) {
            auto &seg_addr = addr.as_seg_paddr();
            auto seg_addr_id = seg_addr.get_segment_id();
-           return trans_intr::parallel_for_each(pin_list, [=, &seg_addr, &list, &t](LBAPinRef &pin) ->
+           return trans_intr::parallel_for_each(pin_list, [=, this, &seg_addr, &list, &t](LBAPinRef &pin) ->
                                                 Cache::get_extent_iertr::future<> {
              auto pin_laddr = pin->get_key();
              auto pin_paddr = pin->get_val();

diff --git a/src/crimson/osd/osd.cc b/src/crimson/osd/osd.cc
index 56303d6e4fcf0831536f3f51c82c917ff41bdce4..7feaa410c2e9f0056a80547b81c106e41b700cb1 100644 (file)
--- a/src/crimson/osd/osd.cc
+++ b/src/crimson/osd/osd.cc
@@ -865,8 +865,8 @@ seastar::future<> OSD::handle_osd_map(crimson::net::ConnectionRef conn,
   }
 
   return seastar::do_with(ceph::os::Transaction{},
-                          [=](auto& t) {
-    return pg_shard_manager.store_maps(t, start, m).then([=, &t] {
+                          [=, this](auto& t) {
+    return pg_shard_manager.store_maps(t, start, m).then([=, this, &t] {
       // even if this map isn't from a mon, we may have satisfied our subscription
       monc->sub_got("osdmap", last);
       if (!superblock.oldest_map || skip_maps) {
@@ -886,7 +886,7 @@ seastar::future<> OSD::handle_osd_map(crimson::net::ConnectionRef conn,
        pg_shard_manager.get_meta_coll().collection(),
        std::move(t));
     });
-  }).then([=] {
+  }).then([=, this] {
     // TODO: write to superblock and commit the transaction
     return committed_osd_maps(start, last, m);
   });

diff --git a/src/crimson/osd/pg.cc b/src/crimson/osd/pg.cc
index 98cb4e831c66ed8f4ad131f7d50d081c7159b1a2..92485972a786f2187980f6e5c9606742d9c0b1db 100644 (file)
--- a/src/crimson/osd/pg.cc
+++ b/src/crimson/osd/pg.cc
@@ -889,7 +889,7 @@ PG::do_osd_ops(
   do_osd_ops_success_func_t success_func,
   do_osd_ops_failure_func_t failure_func)
 {
-  return seastar::do_with(std::move(msg_params), [=, &ops, &op_info]
+  return seastar::do_with(std::move(msg_params), [=, this, &ops, &op_info]
     (auto &msg_params) {
     return do_osd_ops_execute<void>(
       seastar::make_lw_shared<OpsExecuter>(
@@ -919,7 +919,7 @@ PG::interruptible_future<MURef<MOSDOpReply>> PG::do_pg_ops(Ref<MOSDOp> m)
     reply->set_reply_versions(peering_state.get_info().last_update,
       peering_state.get_info().last_user_version);
     return seastar::make_ready_future<MURef<MOSDOpReply>>(std::move(reply));
-  }).handle_exception_type_interruptible([=](const crimson::osd::error& e) {
+  }).handle_exception_type_interruptible([=, this](const crimson::osd::error& e) {
     auto reply = crimson::make_message<MOSDOpReply>(
       m.get(), -e.code().value(), get_osdmap_epoch(), 0, false);
     reply->set_enoent_reply_versions(peering_state.get_info().last_update,

diff --git a/src/crimson/osd/pg_recovery.cc b/src/crimson/osd/pg_recovery.cc
index 9264dda56e109e14202433a2a6255618899a3d1a..78dd07976cbb7a808b661251b7736bd6cc040a4e 100644 (file)
--- a/src/crimson/osd/pg_recovery.cc
+++ b/src/crimson/osd/pg_recovery.cc
@@ -274,7 +274,7 @@ PGRecovery::recover_missing(
       trigger,
       pg->get_recovery_backend()->recover_object(soid, need)
       .handle_exception_interruptible(
-       [=, soid = std::move(soid)] (auto e) {
+       [=, this, soid = std::move(soid)] (auto e) {
        on_failed_recover({ pg->get_pg_whoami() }, soid, need);
        return seastar::make_ready_future<>();
       })
@@ -290,7 +290,7 @@ RecoveryBackend::interruptible_future<> PGRecovery::prep_object_replica_deletes(
   return pg->get_recovery_backend()->add_recovering(soid).wait_track_blocking(
     trigger,
     pg->get_recovery_backend()->push_delete(soid, need).then_interruptible(
-      [=] {
+      [=, this] {
       object_stat_sum_t stat_diff;
       stat_diff.num_objects_recovered = 1;
       on_global_recover(soid, stat_diff, true);
@@ -308,7 +308,7 @@ RecoveryBackend::interruptible_future<> PGRecovery::prep_object_replica_pushes(
     trigger,
     pg->get_recovery_backend()->recover_object(soid, need)
     .handle_exception_interruptible(
-      [=, soid = std::move(soid)] (auto e) {
+      [=, this, soid = std::move(soid)] (auto e) {
       on_failed_recover({ pg->get_pg_whoami() }, soid, need);
       return seastar::make_ready_future<>();
     })

diff --git a/src/crimson/osd/replicated_recovery_backend.cc b/src/crimson/osd/replicated_recovery_backend.cc
index 3adc3a0cc3b66fad9965d35ec60f06b175901958..e5660a388f0d703b761bd3128cfb8c61262d2b49 100644 (file)
--- a/src/crimson/osd/replicated_recovery_backend.cc
+++ b/src/crimson/osd/replicated_recovery_backend.cc
@@ -488,7 +488,7 @@ ReplicatedRecoveryBackend::read_object_for_push_op(
   // 1. get the extents in the interested range
   return interruptor::make_interruptible(backend->fiemap(coll, ghobject_t{oid},
     0, copy_subset.range_end())).safe_then_interruptible(
-    [=](auto&& fiemap_included) mutable {
+    [=, this](auto&& fiemap_included) mutable {
     interval_set<uint64_t> extents;
     try {
       extents.intersection_of(copy_subset, std::move(fiemap_included));