From: Yingxin Cheng Date: Thu, 5 Aug 2021 07:40:43 +0000 (+0800) Subject: crimson/os/seastore: wrap up interruptive-futures in seastore X-Git-Tag: v17.1.0~1148^2~2 X-Git-Url: http://git-server-git.apps.pok.os.sepia.ceph.com/?a=commitdiff_plain;h=b67a65abe040bd995c611d874870ee1e4ae4a657;p=ceph.git crimson/os/seastore: wrap up interruptive-futures in seastore Signed-off-by: Yingxin Cheng --- diff --git a/src/crimson/os/seastore/cache.cc b/src/crimson/os/seastore/cache.cc index 502a35f3ee7b..0389943a3b6f 100644 --- a/src/crimson/os/seastore/cache.cc +++ b/src/crimson/os/seastore/cache.cc @@ -866,21 +866,17 @@ void Cache::init() { add_extent(root); } -Cache::mkfs_ertr::future<> Cache::mkfs(Transaction &t) +Cache::mkfs_iertr::future<> Cache::mkfs(Transaction &t) { - return with_trans_intr( - t, - [this](auto &t) { - return get_root(t).si_then([this, &t](auto croot) { - duplicate_for_write(t, croot); - return base_ertr::now(); - }); - }).handle_error( - mkfs_ertr::pass_further{}, - crimson::ct_error::assert_all{ - "Invalid error in Cache::mkfs" - } - ); + return get_root(t).si_then([this, &t](auto croot) { + duplicate_for_write(t, croot); + return mkfs_iertr::now(); + }).handle_error_interruptible( + mkfs_iertr::pass_further{}, + crimson::ct_error::assert_all{ + "Invalid error in Cache::mkfs" + } + ); } Cache::close_ertr::future<> Cache::close() diff --git a/src/crimson/os/seastore/cache.h b/src/crimson/os/seastore/cache.h index f0a858b42ada..22090c88dbd5 100644 --- a/src/crimson/os/seastore/cache.h +++ b/src/crimson/os/seastore/cache.h @@ -450,9 +450,8 @@ public: * Alloc initial root node and add to t. The intention is for other * components to use t to adjust the resulting root ref prior to commit. */ - using mkfs_ertr = crimson::errorator< - crimson::ct_error::input_output_error>; - mkfs_ertr::future<> mkfs(Transaction &t); + using mkfs_iertr = base_iertr; + mkfs_iertr::future<> mkfs(Transaction &t); /** * close diff --git a/src/crimson/os/seastore/lba_manager.h b/src/crimson/os/seastore/lba_manager.h index 93060fb804f9..2ad5b4596df2 100644 --- a/src/crimson/os/seastore/lba_manager.h +++ b/src/crimson/os/seastore/lba_manager.h @@ -28,12 +28,10 @@ namespace crimson::os::seastore { */ class LBAManager { public: - using base_ertr = Cache::base_ertr; using base_iertr = Cache::base_iertr; - using mkfs_ertr = crimson::errorator< - crimson::ct_error::input_output_error>; - using mkfs_ret = mkfs_ertr::future<>; + using mkfs_iertr = base_iertr; + using mkfs_ret = mkfs_iertr::future<>; virtual mkfs_ret mkfs( Transaction &t ) = 0; @@ -43,7 +41,7 @@ public: * * Future will not resolve until all pins have resolved (set_paddr called) */ - using get_mappings_iertr = trans_iertr; + using get_mappings_iertr = base_iertr; using get_mappings_ret = get_mappings_iertr::future; virtual get_mappings_ret get_mappings( Transaction &t, @@ -63,8 +61,6 @@ public: * * Future will not resolve until the pin has resolved (set_paddr called) */ - using get_mapping_ertr = base_ertr::extend< - crimson::ct_error::enoent>; using get_mapping_iertr = base_iertr::extend< crimson::ct_error::enoent>; using get_mapping_ret = get_mapping_iertr::future; @@ -75,7 +71,6 @@ public: /** * Finds unmapped laddr extent of len len */ - using find_hole_ertr = base_ertr; using find_hole_iertr = base_iertr; using find_hole_ret = find_hole_iertr::future< std::pair @@ -92,7 +87,6 @@ public: * This mapping will block from transaction submission until set_paddr * is called on the LBAPin. */ - using alloc_extent_ertr = base_ertr; using alloc_extent_iertr = base_iertr; using alloc_extent_ret = alloc_extent_iertr::future; virtual alloc_extent_ret alloc_extent( @@ -118,8 +112,6 @@ public: paddr_t addr; extent_len_t length = 0; }; - using ref_ertr = base_ertr::extend< - crimson::ct_error::enoent>; using ref_iertr = base_iertr::extend< crimson::ct_error::enoent>; using ref_ret = ref_iertr::future; diff --git a/src/crimson/os/seastore/lba_manager/btree/btree_lba_manager.cc b/src/crimson/os/seastore/lba_manager/btree/btree_lba_manager.cc index 5bd43fd21c14..b98181ede772 100644 --- a/src/crimson/os/seastore/lba_manager/btree/btree_lba_manager.cc +++ b/src/crimson/os/seastore/lba_manager/btree/btree_lba_manager.cc @@ -23,27 +23,23 @@ BtreeLBAManager::mkfs_ret BtreeLBAManager::mkfs( Transaction &t) { logger().debug("BtreeLBAManager::mkfs"); - return with_trans_intr( - t, - [this](auto &t) { - return cache.get_root(t).si_then([this, &t](auto croot) { - auto root_leaf = cache.alloc_new_extent( - t, - LBA_BLOCK_SIZE); - root_leaf->set_size(0); - lba_node_meta_t meta{0, L_ADDR_MAX, 1}; - root_leaf->set_meta(meta); - root_leaf->pin.set_range(meta); - croot->get_root().lba_root = - lba_root_t{root_leaf->get_paddr(), 1u}; - return mkfs_ertr::now(); - }); - }).handle_error( - mkfs_ertr::pass_further{}, - crimson::ct_error::assert_all{ - "Invalid error in BtreeLBAManager::mkfs" - } - ); + return cache.get_root(t).si_then([this, &t](auto croot) { + auto root_leaf = cache.alloc_new_extent( + t, + LBA_BLOCK_SIZE); + root_leaf->set_size(0); + lba_node_meta_t meta{0, L_ADDR_MAX, 1}; + root_leaf->set_meta(meta); + root_leaf->pin.set_range(meta); + croot->get_root().lba_root = + lba_root_t{root_leaf->get_paddr(), 1u}; + return mkfs_iertr::now(); + }).handle_error_interruptible( + mkfs_iertr::pass_further{}, + crimson::ct_error::assert_all{ + "Invalid error in BtreeLBAManager::mkfs" + } + ); } BtreeLBAManager::get_root_ret diff --git a/src/crimson/os/seastore/onode_manager.h b/src/crimson/os/seastore/onode_manager.h index b68c9718b1d9..123c9e4f865e 100644 --- a/src/crimson/os/seastore/onode_manager.h +++ b/src/crimson/os/seastore/onode_manager.h @@ -22,13 +22,10 @@ namespace crimson::os::seastore { class OnodeManager { - using base_ertr = crimson::errorator< - crimson::ct_error::eagain>; - - using base_iertr = trans_iertr; + using base_iertr = TransactionManager::base_iertr; public: - using mkfs_ertr = base_ertr; - using mkfs_ret = mkfs_ertr::future<>; + using mkfs_iertr = base_iertr; + using mkfs_ret = mkfs_iertr::future<>; virtual mkfs_ret mkfs(Transaction &t) = 0; using contains_onode_iertr = base_iertr; diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/fwd.h b/src/crimson/os/seastore/onode_manager/staged-fltree/fwd.h index 3f9684620152..9adba5e34e23 100644 --- a/src/crimson/os/seastore/onode_manager/staged-fltree/fwd.h +++ b/src/crimson/os/seastore/onode_manager/staged-fltree/fwd.h @@ -17,12 +17,8 @@ namespace crimson::os::seastore::onode { -using eagain_ertr = crimson::errorator< - crimson::ct_error::eagain>; -template -using eagain_future = eagain_ertr::future; - -using eagain_iertr = trans_iertr; +using eagain_iertr = trans_iertr< + crimson::errorator >; template using eagain_ifuture = eagain_iertr::future; diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/node.cc b/src/crimson/os/seastore/onode_manager/staged-fltree/node.cc index 1d5325b16e04..b6feac38e283 100644 --- a/src/crimson/os/seastore/onode_manager/staged-fltree/node.cc +++ b/src/crimson/os/seastore/onode_manager/staged-fltree/node.cc @@ -397,15 +397,11 @@ void Node::test_make_destructable( make_root(c, std::move(_super)); } -eagain_future<> Node::mkfs(context_t c, RootNodeTracker& root_tracker) +eagain_ifuture<> Node::mkfs(context_t c, RootNodeTracker& root_tracker) { LOG_PREFIX(OTree::Node::mkfs); - return with_trans_intr( - c.t, - [c, &root_tracker](auto &t) { - return LeafNode::allocate_root(c, root_tracker); - } - ).safe_then([c, FNAME](auto ret) { + return LeafNode::allocate_root(c, root_tracker + ).si_then([c, FNAME](auto ret) { INFOT("allocated root {}", c.t, ret->get_name()); }); } @@ -421,6 +417,7 @@ eagain_ifuture> Node::load_root(context_t c, RootNodeTracker& root_tra ceph_abort("fatal error"); }) ).si_then([c, &root_tracker, FNAME](auto&& _super) { + assert(_super); auto root_addr = _super->get_root_laddr(); assert(root_addr != L_ADDR_NULL); TRACET("loading root_addr={:x} ...", c.t, root_addr); @@ -703,6 +700,7 @@ eagain_ifuture> Node::load( }) ).si_then([FNAME, c, addr, expect_is_level_tail](auto extent) -> eagain_ifuture> { + assert(extent); auto header = extent->get_header(); auto field_type = header.get_field_type(); if (!field_type) { @@ -1390,6 +1388,7 @@ eagain_ifuture<> InternalNode::test_clone_root( eagain_iertr::pass_further{}, crimson::ct_error::assert_all{"Invalid error during test clone"} ).si_then([c_other, cloned_root](auto&& super_other) { + assert(super_other); cloned_root->make_root_new(c_other, std::move(super_other)); return cloned_root; }); @@ -2023,6 +2022,7 @@ eagain_ifuture<> LeafNode::test_clone_root( eagain_iertr::pass_further{}, crimson::ct_error::assert_all{"Invalid error during test clone"} ).si_then([c_other, cloned_root](auto&& super_other) { + assert(super_other); cloned_root->make_root_new(c_other, std::move(super_other)); }); }).si_then([this_ref]{}); @@ -2110,6 +2110,7 @@ eagain_ifuture> LeafNode::allocate_root( ceph_abort("fatal error"); }) ).si_then([c, root](auto&& super) { + assert(super); root->make_root_new(c, std::move(super)); return root; }); diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/node.h b/src/crimson/os/seastore/onode_manager/staged-fltree/node.h index d51ee004da0b..7597b0cf6937 100644 --- a/src/crimson/os/seastore/onode_manager/staged-fltree/node.h +++ b/src/crimson/os/seastore/onode_manager/staged-fltree/node.h @@ -360,7 +360,7 @@ class Node const std::string& get_name() const; /// Initializes the tree by allocating an empty root node. - static eagain_future<> mkfs(context_t, RootNodeTracker&); + static eagain_ifuture<> mkfs(context_t, RootNodeTracker&); /// Loads the tree root. The tree must be initialized. static eagain_ifuture> load_root(context_t, RootNodeTracker&); diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_accessor.h b/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_accessor.h index 0765d53cd2a2..b6a2f0315893 100644 --- a/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_accessor.h +++ b/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_accessor.h @@ -527,6 +527,7 @@ class NodeExtentAccessorT { ).si_then([this, c, FNAME] (auto fresh_extent) { DEBUGT("update addr from {:#x} to {:#x} ...", c.t, extent->get_laddr(), fresh_extent->get_laddr()); + assert(fresh_extent); assert(fresh_extent->is_initial_pending()); assert(fresh_extent->get_recorder() == nullptr); assert(get_length() == fresh_extent->get_length()); @@ -559,7 +560,8 @@ class NodeExtentAccessorT { ceph_abort("fatal error"); }) ); - }).si_then([this] { + }).si_then([this, c] { + assert(!c.t.is_conflicted()); return *mut; }); } @@ -581,6 +583,11 @@ class NodeExtentAccessorT { ERRORT("ENOENT -- addr={:x}", c.t, addr); ceph_abort("fatal error"); }) +#ifndef NDEBUG + ).si_then([this, c] { + assert(!c.t.is_conflicted()); + } +#endif ); } diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_manager.h b/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_manager.h index 36f1f294ebfd..b33c9d539b10 100644 --- a/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_manager.h +++ b/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_manager.h @@ -62,12 +62,7 @@ class NodeExtent : public LogicalCachedExtent { using crimson::os::seastore::TransactionManager; class NodeExtentManager { - using base_ertr = eagain_ertr::extend< - crimson::ct_error::input_output_error>; - - using eagain_iertr = trans_iertr; - using base_iertr = eagain_iertr::extend< - crimson::ct_error::input_output_error>; + using base_iertr = TransactionManager::base_iertr; public: virtual ~NodeExtentManager() = default; diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_manager/seastore.h b/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_manager/seastore.h index 821b5561d4e7..262c10bb3fd2 100644 --- a/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_manager/seastore.h +++ b/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_manager/seastore.h @@ -106,7 +106,8 @@ class SeastoreNodeExtentManager final: public TransactionManagerHandle { if constexpr (INJECT_EAGAIN) { if (trigger_eagain()) { DEBUGT("reading at {:#x}: trigger eagain", t, addr); - return crimson::ct_error::eagain::make(); + t.test_set_conflict(); + return read_iertr::make_ready_future(); } } return tm.read_extent(t, addr @@ -125,7 +126,8 @@ class SeastoreNodeExtentManager final: public TransactionManagerHandle { if constexpr (INJECT_EAGAIN) { if (trigger_eagain()) { DEBUGT("allocating {}B: trigger eagain", t, len); - return crimson::ct_error::eagain::make(); + t.test_set_conflict(); + return alloc_iertr::make_ready_future(); } } return tm.alloc_extent(t, addr_min, len @@ -154,7 +156,8 @@ class SeastoreNodeExtentManager final: public TransactionManagerHandle { if (trigger_eagain()) { DEBUGT("retiring {}B at {:#x} -- {} : trigger eagain", t, len, addr, *extent); - return crimson::ct_error::eagain::make(); + t.test_set_conflict(); + return retire_iertr::now(); } } return tm.dec_ref(t, extent).si_then([addr, len, &t] (unsigned cnt) { @@ -169,7 +172,8 @@ class SeastoreNodeExtentManager final: public TransactionManagerHandle { if constexpr (INJECT_EAGAIN) { if (trigger_eagain()) { DEBUGT("get root: trigger eagain", t); - return crimson::ct_error::eagain::make(); + t.test_set_conflict(); + return getsuper_iertr::make_ready_future(); } } return tm.read_onode_root(t).si_then([this, &t, &tracker](auto root_addr) { diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/node_layout.h b/src/crimson/os/seastore/onode_manager/staged-fltree/node_layout.h index 73a5b63f8220..4c55d49475da 100644 --- a/src/crimson/os/seastore/onode_manager/staged-fltree/node_layout.h +++ b/src/crimson/os/seastore/onode_manager/staged-fltree/node_layout.h @@ -84,6 +84,7 @@ class NodeLayoutT final : public InternalNodeImpl, public LeafNodeImpl { ceph_abort("fatal error"); }) ).si_then([is_level_tail, level](auto extent) { + assert(extent); assert(extent->is_initial_pending()); auto mut = extent->get_mutable(); node_stage_t::bootstrap_extent( diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/tree.h b/src/crimson/os/seastore/onode_manager/staged-fltree/tree.h index ae4c40e3dfb5..b6a282e03b35 100644 --- a/src/crimson/os/seastore/onode_manager/staged-fltree/tree.h +++ b/src/crimson/os/seastore/onode_manager/staged-fltree/tree.h @@ -47,7 +47,7 @@ class Btree { Btree& operator=(const Btree&) = delete; Btree& operator=(Btree&&) = delete; - eagain_future<> mkfs(Transaction& t) { + eagain_ifuture<> mkfs(Transaction& t) { return Node::mkfs(get_context(t), *root_tracker); } diff --git a/src/crimson/os/seastore/seastore.cc b/src/crimson/os/seastore/seastore.cc index 44c599b6e809..75140368351d 100644 --- a/src/crimson/os/seastore/seastore.cc +++ b/src/crimson/os/seastore/seastore.cc @@ -119,25 +119,17 @@ seastar::future<> SeaStore::mkfs(uuid_d new_osd_fsid) }).safe_then([this] { return transaction_manager->mount(); }).safe_then([this] { - return seastar::do_with( - transaction_manager->create_transaction( - Transaction::src_t::MUTATE), - [this](auto &t) { - return onode_manager->mkfs(*t - ).safe_then([this, &t] { - return with_trans_intr( - *t, - [this](auto &t) { - return collection_manager->mkfs(t); - }); - }).safe_then([this, &t](auto coll_root) { - transaction_manager->write_collection_root( - *t, - coll_root); - return transaction_manager->submit_transaction( - *t); - }); + return transaction_manager->with_transaction_intr( + Transaction::src_t::MUTATE, [this](auto& t) { + return onode_manager->mkfs(t + ).si_then([this, &t] { + return collection_manager->mkfs(t); + }).si_then([this, &t](auto coll_root) { + transaction_manager->write_collection_root( + t, coll_root); + return transaction_manager->submit_transaction(t); }); + }); }).safe_then([this] { return umount(); }).handle_error( @@ -166,22 +158,21 @@ SeaStore::list_objects(CollectionRef ch, return seastar::do_with( RetType(), [this, start, end, limit] (auto& ret) { - return repeat_eagain2([this, start, end, limit, &ret] { - return seastar::do_with( - transaction_manager->create_transaction( - Transaction::src_t::READ), - [this, start, end, limit, &ret] (auto& t) { - return with_trans_intr( - *t, - [this, start, end, limit](auto &t) { - return onode_manager->list_onodes(t, start, end, limit); - }).safe_then([&ret] (auto&& _ret) { - ret = std::move(_ret); - }); + return repeat_eagain([this, start, end, limit, &ret] { + return transaction_manager->with_transaction_intr( + Transaction::src_t::READ, + [this, start, end, limit](auto &t) { + return onode_manager->list_onodes(t, start, end, limit); + }).safe_then([&ret](auto&& _ret) { + ret = std::move(_ret); }); - }).then([&ret] { + }).safe_then([&ret] { return std::move(ret); - }); + }).handle_error( + crimson::ct_error::assert_all{ + "Invalid error in SeaStore::list_objects" + } + ); }); } @@ -212,35 +203,28 @@ seastar::future> SeaStore::list_collections() std::vector(), [this](auto &ret) { return repeat_eagain([this, &ret] { - - return seastar::do_with( - transaction_manager->create_transaction( - Transaction::src_t::READ), - [this, &ret](auto &t) { - return transaction_manager->read_collection_root(*t - ).safe_then([this, &t](auto coll_root) { - return with_trans_intr( - *t, - [this, &coll_root](auto &t) { - return collection_manager->list( - coll_root, - t); - }); - }).safe_then([&ret](auto colls) { - ret.resize(colls.size()); - std::transform( - colls.begin(), colls.end(), ret.begin(), - [](auto p) { return p.first; }); - }); - }); + return transaction_manager->with_transaction_intr( + Transaction::src_t::READ, + [this, &ret](auto& t) { + return transaction_manager->read_collection_root(t + ).si_then([this, &t](auto coll_root) { + return collection_manager->list(coll_root, t); + }).si_then([&ret](auto colls) { + ret.resize(colls.size()); + std::transform( + colls.begin(), colls.end(), ret.begin(), + [](auto p) { return p.first; }); + }); + }); }).safe_then([&ret] { - return seastar::make_ready_future>(ret); + return seastar::make_ready_future>(ret); }); - }).handle_error( - crimson::ct_error::assert_all{ - "Invalid error in SeaStore::list_collections" - } - ); + } + ).handle_error( + crimson::ct_error::assert_all{ + "Invalid error in SeaStore::list_collections" + } + ); } SeaStore::read_errorator::future SeaStore::read( @@ -257,8 +241,7 @@ SeaStore::read_errorator::future SeaStore::read( oid, Transaction::src_t::READ, op_type_t::READ, - [=](auto &t, auto &onode) - -> with_trans_ertr::future { + [=](auto &t, auto &onode) -> ObjectDataHandler::read_ret { size_t size = onode.get_layout().size; if (offset >= size) { @@ -269,16 +252,14 @@ SeaStore::read_errorator::future SeaStore::read( size - offset : std::min(size - offset, len); - return with_trans_intr(t, [&](auto &t) { - return ObjectDataHandler().read( - ObjectDataHandler::context_t{ - transaction_manager->get_tm(), - t, - onode, - }, - offset, - corrected_len); - }); + return ObjectDataHandler().read( + ObjectDataHandler::context_t{ + *transaction_manager, + t, + onode, + }, + offset, + corrected_len); }); } @@ -306,7 +287,7 @@ SeaStore::get_attr_errorator::future SeaStore::get_attr( oid, Transaction::src_t::READ, op_type_t::GET_ATTR, - [=](auto &t, auto& onode) -> _omap_get_value_ertr::future { + [=](auto &t, auto& onode) -> _omap_get_value_ret { auto& layout = onode.get_layout(); if (name == OI_ATTR && layout.oi_size) { ceph::bufferlist bl; @@ -345,7 +326,7 @@ SeaStore::get_attrs_ertr::future SeaStore::get_attrs( auto& layout = onode.get_layout(); return _omap_list(layout.xattr_root, t, std::nullopt, OMapManager::omap_list_config_t::with_inclusive(false) - ).safe_then([&layout](auto p) { + ).si_then([&layout](auto p) { auto& attrs = std::get<1>(p); ceph::bufferlist bl; if (layout.oi_size) { @@ -429,26 +410,22 @@ SeaStore::_omap_get_value_ret SeaStore::_omap_get_value( std::string_view key) const { return seastar::do_with( - BtreeOMapManager(transaction_manager->get_tm()), + BtreeOMapManager(*transaction_manager), std::move(root), std::string(key), [&t](auto &manager, auto& root, auto& key) -> _omap_get_value_ret { if (root.is_null()) { - return crimson::ct_error::enodata::make(); + return crimson::ct_error::enodata::make(); } - return with_trans_intr( - t, - [&](auto &t) { - return manager.omap_get_value( - root, t, key - ); - }).safe_then([](auto opt) -> _omap_get_value_ret { - if (!opt) { - return crimson::ct_error::enodata::make(); - } - return seastar::make_ready_future(std::move(*opt)); - }); - }); + return manager.omap_get_value(root, t, key + ).si_then([](auto opt) -> _omap_get_value_ret { + if (!opt) { + return crimson::ct_error::enodata::make(); + } + return seastar::make_ready_future(std::move(*opt)); + }); + } + ); } SeaStore::_omap_get_values_ret SeaStore::_omap_get_values( @@ -460,36 +437,34 @@ SeaStore::_omap_get_values_ret SeaStore::_omap_get_values( return seastar::make_ready_future(); } return seastar::do_with( - BtreeOMapManager(transaction_manager->get_tm()), + BtreeOMapManager(*transaction_manager), std::move(omap_root), omap_values_t(), [&](auto &manager, auto &root, auto &ret) { - return with_trans_intr( - t, - [&](auto &t) { - return trans_intr::do_for_each( - keys.begin(), - keys.end(), - [&](auto &key) { - return manager.omap_get_value( - root, - t, - key - ).si_then([&ret, &key](auto &&p) { - if (p) { - bufferlist bl; - bl.append(*p); - ret.emplace( - std::move(key), - std::move(bl)); - } - return seastar::now(); - }); - }).si_then([&ret] { - return std::move(ret); - }); - }); - }); + return trans_intr::do_for_each( + keys.begin(), + keys.end(), + [&](auto &key) { + return manager.omap_get_value( + root, + t, + key + ).si_then([&ret, &key](auto &&p) { + if (p) { + bufferlist bl; + bl.append(*p); + ret.emplace( + std::move(key), + std::move(bl)); + } + return seastar::now(); + }); + } + ).si_then([&ret] { + return std::move(ret); + }); + } + ); } SeaStore::_omap_list_ret SeaStore::_omap_list( @@ -505,15 +480,11 @@ SeaStore::_omap_list_ret SeaStore::_omap_list( ); } return seastar::do_with( - BtreeOMapManager(transaction_manager->get_tm()), + BtreeOMapManager(*transaction_manager), root, start, [&t, config](auto &manager, auto& root, auto& start) { - return with_trans_intr( - t, - [&](auto &t) { - return manager.omap_list(root, t, start, config); - }); + return manager.omap_list(root, t, start, config); }); } @@ -684,51 +655,45 @@ seastar::future<> SeaStore::do_transaction( Transaction::src_t::MUTATE, op_type_t::TRANSACTION, [this](auto &ctx) { - return with_trans_intr( - *ctx.transaction, - [&](auto &t) { + return with_trans_intr(*ctx.transaction, [&, this](auto &t) { return onode_manager->get_or_create_onodes( - *ctx.transaction, ctx.iter.get_objects()); - } - ).safe_then([this, &ctx](auto &&read_onodes) { - ctx.onodes = std::move(read_onodes); - return crimson::repeat( - [this, &ctx]() -> tm_ertr::future { - if (ctx.iter.have_op()) { - return _do_transaction_step( - ctx, ctx.ch, ctx.onodes, ctx.iter - ).safe_then([] { - return seastar::make_ready_future( - seastar::stop_iteration::no); - }); - } else { - return seastar::make_ready_future( - seastar::stop_iteration::yes); - }; - }); - }).safe_then([this, &ctx] { - return with_trans_intr( - *ctx.transaction, - [&](auto &t) { - return onode_manager->write_dirty(*ctx.transaction, ctx.onodes); - } - ); - }).safe_then([this, &ctx] { - // There are some validations in onode tree during onode value - // destruction in debug mode, which need to be done before calling - // submit_transaction(). - ctx.onodes.clear(); - return transaction_manager->submit_transaction(*ctx.transaction); + *ctx.transaction, ctx.iter.get_objects() + ).si_then([this, &ctx](auto &&read_onodes) { + ctx.onodes = std::move(read_onodes); + return trans_intr::repeat( + [this, &ctx]() -> tm_iertr::future { + if (ctx.iter.have_op()) { + return _do_transaction_step( + ctx, ctx.ch, ctx.onodes, ctx.iter + ).si_then([] { + return seastar::make_ready_future( + seastar::stop_iteration::no); + }); + } else { + return seastar::make_ready_future( + seastar::stop_iteration::yes); + }; + } + ); + }).si_then([this, &ctx] { + return onode_manager->write_dirty(*ctx.transaction, ctx.onodes); + }).si_then([this, &ctx] { + // There are some validations in onode tree during onode value + // destruction in debug mode, which need to be done before calling + // submit_transaction(). + ctx.onodes.clear(); + return transaction_manager->submit_transaction(*ctx.transaction); + }); }).safe_then([&ctx]() { - for (auto i : { - ctx.ext_transaction.get_on_applied(), - ctx.ext_transaction.get_on_commit(), - ctx.ext_transaction.get_on_applied_sync()}) { - if (i) { - i->complete(0); - } - } - return tm_ertr::now(); + for (auto i : { + ctx.ext_transaction.get_on_applied(), + ctx.ext_transaction.get_on_commit(), + ctx.ext_transaction.get_on_applied_sync()}) { + if (i) { + i->complete(0); + } + } + return seastar::now(); }); }); } @@ -749,7 +714,7 @@ SeaStore::tm_ret SeaStore::_do_transaction_step( try { switch (auto op = i.decode_op(); op->op) { case Transaction::OP_NOP: - return tm_ertr::now(); + return tm_iertr::now(); case Transaction::OP_REMOVE: { return _remove(ctx, get_onode(op->oid)); @@ -834,7 +799,7 @@ SeaStore::tm_ret SeaStore::_do_transaction_step( { ceph::bufferlist hint; i.decode_bl(hint); - return tm_ertr::now(); + return tm_iertr::now(); } default: ERROR("bad op {}", static_cast(op->op)); @@ -852,12 +817,7 @@ SeaStore::tm_ret SeaStore::_remove( { LOG_PREFIX(SeaStore::_remove); DEBUGT("onode={}", *ctx.transaction, *onode); - return with_trans_intr( - *ctx.transaction, - [&](auto &t) { - return onode_manager->erase_onode(*ctx.transaction, onode); - } - ); + return onode_manager->erase_onode(*ctx.transaction, onode); } SeaStore::tm_ret SeaStore::_touch( @@ -866,7 +826,7 @@ SeaStore::tm_ret SeaStore::_touch( { LOG_PREFIX(SeaStore::_touch); DEBUGT("onode={}", *ctx.transaction, *onode); - return tm_ertr::now(); + return tm_iertr::now(); } SeaStore::tm_ret SeaStore::_write( @@ -887,16 +847,14 @@ SeaStore::tm_ret SeaStore::_write( return seastar::do_with( std::move(_bl), [=, &ctx, &onode](auto &bl) { - return with_trans_intr(*ctx.transaction, [&](auto &t) { - return ObjectDataHandler().write( - ObjectDataHandler::context_t{ - transaction_manager->get_tm(), - t, - *onode, - }, - offset, - bl); - }); + return ObjectDataHandler().write( + ObjectDataHandler::context_t{ + *transaction_manager, + *ctx.transaction, + *onode, + }, + offset, + bl); }); } @@ -908,32 +866,29 @@ SeaStore::_omap_set_kvs( std::map&& kvs) { return seastar::do_with( - BtreeOMapManager(transaction_manager->get_tm()), + BtreeOMapManager(*transaction_manager), omap_root.get(), [&, keys=std::move(kvs)](auto &omap_manager, auto &root) { - return with_trans_intr( - t, - [&](auto &t) { - tm_iertr::future<> maybe_create_root = - !root.is_null() ? - tm_iertr::now() : - omap_manager.initialize_omap( - t - ).si_then([&root](auto new_root) { - root = new_root; - }); - return maybe_create_root.si_then( - [&, keys=std::move(keys)]() mutable { - return omap_manager.omap_set_keys(root, t, std::move(keys)); - }).si_then([&] { - return tm_iertr::make_ready_future(std::move(root)); - }).si_then([&mutable_omap_root](auto root) { - if (root.must_update()) { - mutable_omap_root.update(root); - } - }); - }); - }); + tm_iertr::future<> maybe_create_root = + !root.is_null() ? + tm_iertr::now() : + omap_manager.initialize_omap( + t + ).si_then([&root](auto new_root) { + root = new_root; + }); + return maybe_create_root.si_then( + [&, keys=std::move(keys)]() mutable { + return omap_manager.omap_set_keys(root, t, std::move(keys)); + }).si_then([&] { + return tm_iertr::make_ready_future(std::move(root)); + }).si_then([&mutable_omap_root](auto root) { + if (root.must_update()) { + mutable_omap_root.update(root); + } + }); + } + ); } SeaStore::tm_ret SeaStore::_omap_set_values( @@ -958,7 +913,7 @@ SeaStore::tm_ret SeaStore::_omap_set_header( LOG_PREFIX(SeaStore::_omap_set_header); DEBUGT("{} {} bytes", *ctx.transaction, *onode, header.length()); assert(0 == "not supported yet"); - return tm_ertr::now(); + return tm_iertr::now(); } SeaStore::tm_ret SeaStore::_omap_rmkeys( @@ -973,32 +928,30 @@ SeaStore::tm_ret SeaStore::_omap_rmkeys( return seastar::now(); } else { return seastar::do_with( - BtreeOMapManager(transaction_manager->get_tm()), + BtreeOMapManager(*transaction_manager), onode->get_layout().omap_root.get(), std::move(keys), [&ctx, &onode]( auto &omap_manager, auto &omap_root, auto &keys) { - return with_trans_intr( - *ctx.transaction, - [&](auto &t) { - return trans_intr::do_for_each( - keys.begin(), - keys.end(), - [&](auto &p) { - return omap_manager.omap_rm_key( - omap_root, - *ctx.transaction, - p); - }).si_then([&] { - if (omap_root.must_update()) { - onode->get_mutable_layout(*ctx.transaction - ).omap_root.update(omap_root); - } - }); - }); - }); + return trans_intr::do_for_each( + keys.begin(), + keys.end(), + [&](auto &p) { + return omap_manager.omap_rm_key( + omap_root, + *ctx.transaction, + p); + } + ).si_then([&] { + if (omap_root.must_update()) { + onode->get_mutable_layout(*ctx.transaction + ).omap_root.update(omap_root); + } + }); + } + ); } } @@ -1011,7 +964,7 @@ SeaStore::tm_ret SeaStore::_omap_rmkeyrange( LOG_PREFIX(SeaStore::_omap_rmkeyrange); DEBUGT("{} first={} last={}", *ctx.transaction, *onode, first, last); assert(0 == "not supported yet"); - return tm_ertr::now(); + return tm_iertr::now(); } SeaStore::tm_ret SeaStore::_truncate( @@ -1022,15 +975,13 @@ SeaStore::tm_ret SeaStore::_truncate( LOG_PREFIX(SeaStore::_truncate); DEBUGT("onode={} size={}", *ctx.transaction, *onode, size); onode->get_mutable_layout(*ctx.transaction).size = size; - return with_trans_intr(*ctx.transaction, [&](auto &t) { - return ObjectDataHandler().truncate( - ObjectDataHandler::context_t{ - transaction_manager->get_tm(), - t, - *onode - }, - size); - }); + return ObjectDataHandler().truncate( + ObjectDataHandler::context_t{ + *transaction_manager, + *ctx.transaction, + *onode + }, + size); } SeaStore::tm_ret SeaStore::_setattrs( @@ -1072,7 +1023,7 @@ SeaStore::tm_ret SeaStore::_setattrs( } if (aset.empty()) { - return tm_ertr::now(); + return tm_iertr::now(); } return _omap_set_kvs( @@ -1088,28 +1039,26 @@ SeaStore::tm_ret SeaStore::_create_collection( { return transaction_manager->read_collection_root( *ctx.transaction - ).safe_then([=, &ctx](auto _cmroot) { + ).si_then([=, &ctx](auto _cmroot) { return seastar::do_with( _cmroot, [=, &ctx](auto &cmroot) { - return with_trans_intr( - *ctx.transaction, - [=, &cmroot](auto &t) { - return collection_manager->create( - cmroot, - t, - cid, - bits); - }).safe_then([=, &ctx, &cmroot] { - if (cmroot.must_update()) { - transaction_manager->write_collection_root( - *ctx.transaction, - cmroot); - } - }); - }); - }).handle_error( - tm_ertr::pass_further{}, + return collection_manager->create( + cmroot, + *ctx.transaction, + cid, + bits + ).si_then([=, &ctx, &cmroot] { + if (cmroot.must_update()) { + transaction_manager->write_collection_root( + *ctx.transaction, + cmroot); + } + }); + } + ); + }).handle_error_interruptible( + tm_iertr::pass_further{}, crimson::ct_error::assert_all{ "Invalid error in SeaStore::_create_collection" } @@ -1122,28 +1071,25 @@ SeaStore::tm_ret SeaStore::_remove_collection( { return transaction_manager->read_collection_root( *ctx.transaction - ).safe_then([=, &ctx](auto _cmroot) { + ).si_then([=, &ctx](auto _cmroot) { return seastar::do_with( _cmroot, [=, &ctx](auto &cmroot) { - return with_trans_intr( - *ctx.transaction, - [=, &cmroot](auto &t) { - return collection_manager->remove( - cmroot, - t, - cid); - }).safe_then([=, &ctx, &cmroot] { - // param here denotes whether it already existed, probably error - if (cmroot.must_update()) { - transaction_manager->write_collection_root( - *ctx.transaction, - cmroot); - } - }); + return collection_manager->remove( + cmroot, + *ctx.transaction, + cid + ).si_then([=, &ctx, &cmroot] { + // param here denotes whether it already existed, probably error + if (cmroot.must_update()) { + transaction_manager->write_collection_root( + *ctx.transaction, + cmroot); + } + }); }); - }).handle_error( - tm_ertr::pass_further{}, + }).handle_error_interruptible( + tm_iertr::pass_further{}, crimson::ct_error::assert_all{ "Invalid error in SeaStore::_create_collection" } @@ -1161,23 +1107,23 @@ seastar::future<> SeaStore::write_meta(const std::string& key, LOG_PREFIX(SeaStore::write_meta); DEBUG("key: {}; value: {}", key, value); return seastar::do_with( - TransactionRef(), - key, - value, - [this, FNAME](auto &t, auto& key, auto& value) { - return repeat_eagain([this, FNAME, &t, &key, &value] { - t = transaction_manager->create_transaction( - Transaction::src_t::MUTATE); - DEBUGT("Have transaction, key: {}; value: {}", *t, key, value); + key, value, + [this, FNAME](auto& key, auto& value) { + return repeat_eagain([this, FNAME, &key, &value] { + return transaction_manager->with_transaction_intr( + Transaction::src_t::MUTATE, + [this, FNAME, &key, &value](auto& t) { + DEBUGT("Have transaction, key: {}; value: {}", t, key, value); return transaction_manager->update_root_meta( - *t, key, value - ).safe_then([this, &t] { - return transaction_manager->submit_transaction(*t); - }); + t, key, value + ).si_then([this, &t] { + return transaction_manager->submit_transaction(t); + }); }); - }).handle_error( - crimson::ct_error::assert_all{"Invalid error in SeaStore::write_meta"} - ); + }); + }).handle_error( + crimson::ct_error::assert_all{"Invalid error in SeaStore::write_meta"} + ); } seastar::future> SeaStore::read_meta(const std::string& key) @@ -1185,28 +1131,28 @@ seastar::future> SeaStore::read_meta(const std::str LOG_PREFIX(SeaStore::read_meta); DEBUG("key: {}", key); return seastar::do_with( - std::tuple(), - TransactionRef(), - key, - [this](auto &ret, auto &t, auto& key) { - return repeat_eagain([this, &ret, &t, &key] { - t = transaction_manager->create_transaction( - Transaction::src_t::READ); - return transaction_manager->read_root_meta( - *t, key - ).safe_then([&ret](auto v) { - if (v) { - ret = std::make_tuple(0, std::move(*v)); - } else { - ret = std::make_tuple(-1, std::string("")); - } - }); - }).safe_then([&ret] { - return std::move(ret); + std::tuple(), key, + [this](auto &ret, auto& key) { + return repeat_eagain([this, &ret, &key] { + return transaction_manager->with_transaction_intr( + Transaction::src_t::READ, + [this, &ret, &key](auto& t) { + return transaction_manager->read_root_meta( + t, key + ).si_then([&ret](auto v) { + if (v) { + ret = std::make_tuple(0, std::move(*v)); + } else { + ret = std::make_tuple(-1, std::string("")); + } + }); }); - }).handle_error( - crimson::ct_error::assert_all{"Invalid error in SeaStore::read_meta"} - ); + }).safe_then([&ret] { + return std::move(ret); + }); + }).handle_error( + crimson::ct_error::assert_all{"Invalid error in SeaStore::read_meta"} + ); } uuid_d SeaStore::get_fsid() const diff --git a/src/crimson/os/seastore/seastore.h b/src/crimson/os/seastore/seastore.h index 27768fe6ae74..f757d9b8a3aa 100644 --- a/src/crimson/os/seastore/seastore.h +++ b/src/crimson/os/seastore/seastore.h @@ -159,9 +159,8 @@ private: ceph::os::Transaction::iterator iter; std::chrono::steady_clock::time_point begin_timestamp = std::chrono::steady_clock::now(); - template - void reset_preserve_handle(TM &tm) { - tm->reset_transaction_preserve_handle(*transaction); + void reset_preserve_handle(TransactionManager &tm) { + tm.reset_transaction_preserve_handle(*transaction); onodes.clear(); iter = ext_transaction.begin(); } @@ -186,7 +185,7 @@ private: static_cast(*(ctx.ch)).ordering_lock ).then([&, this] { return repeat_eagain([&, this] { - ctx.reset_preserve_handle(transaction_manager); + ctx.reset_preserve_handle(*transaction_manager); return std::invoke(f, ctx); }).handle_error( crimson::ct_error::eagain::pass_further{}, @@ -198,7 +197,8 @@ private: add_latency_sample(op_type, std::chrono::steady_clock::now() - ctx.begin_timestamp); }); - }); + } + ); } template @@ -210,52 +210,45 @@ private: F &&f) const { auto begin_time = std::chrono::steady_clock::now(); return seastar::do_with( - oid, - Ret{}, - TransactionRef(), - OnodeRef(), - std::forward(f), - [=](auto &oid, auto &ret, auto &t, auto &onode, auto &f) { - return repeat_eagain([&, this, src] { - t = transaction_manager->create_transaction(src); - return with_trans_intr( - *t, - [&](auto &t) { - return onode_manager->get_onode(t, oid); - } - ).safe_then([&](auto onode_ret) { - onode = std::move(onode_ret); - return f(*t, *onode); - }).safe_then([&ret](auto _ret) { - ret = _ret; - }); - }).safe_then([&ret, op_type, begin_time, this] { - const_cast(this)->add_latency_sample(op_type, - std::chrono::steady_clock::now() - begin_time); - return seastar::make_ready_future(ret); - }); + oid, Ret{}, OnodeRef(), std::forward(f), + [this, src, op_type, begin_time](auto &oid, auto &ret, auto &onode, auto &f) { + return repeat_eagain([&, this, src] { + return transaction_manager->with_transaction_intr( + src, [&, this](auto& t) { + return onode_manager->get_onode(t, oid + ).si_then([&](auto onode_ret) { + onode = std::move(onode_ret); + return f(t, *onode); + }).si_then([&ret](auto _ret) { + ret = _ret; + }); + }); + }).safe_then([&ret, op_type, begin_time, this] { + const_cast(this)->add_latency_sample(op_type, + std::chrono::steady_clock::now() - begin_time); + return seastar::make_ready_future(ret); }); + }); } - using _omap_get_value_ertr = with_trans_ertr::extend< + using _omap_get_value_iertr = OMapManager::base_iertr::extend< crimson::ct_error::enodata >; - using _omap_get_value_ret = _omap_get_value_ertr::future; + using _omap_get_value_ret = _omap_get_value_iertr::future; _omap_get_value_ret _omap_get_value( Transaction &t, omap_root_t &&root, std::string_view key) const; - using _omap_get_values_ertr = with_trans_ertr; - using _omap_get_values_ret = _omap_get_values_ertr::future; + using _omap_get_values_iertr = OMapManager::base_iertr; + using _omap_get_values_ret = _omap_get_values_iertr::future; _omap_get_values_ret _omap_get_values( Transaction &t, omap_root_t &&root, const omap_keys_t &keys) const; using _omap_list_bare_ret = OMapManager::omap_list_bare_ret; - using _omap_list_ret = - _omap_get_values_ertr::future; + using _omap_list_ret = OMapManager::omap_list_ret; _omap_list_ret _omap_list( const omap_root_le_t& omap_root, Transaction& t, @@ -270,13 +263,12 @@ private: OMapManager::omap_list_config_t config); SegmentManagerRef segment_manager; - InterruptedTMRef transaction_manager; + TransactionManagerRef transaction_manager; CollectionManagerRef collection_manager; OnodeManagerRef onode_manager; using tm_iertr = TransactionManager::base_iertr; - using tm_ertr = with_trans_ertr; - using tm_ret = tm_ertr::future<>; + using tm_ret = tm_iertr::future<>; tm_ret _do_transaction_step( internal_context_t &ctx, CollectionRef &col, @@ -325,7 +317,7 @@ private: tm_ret _remove_collection( internal_context_t &ctx, const coll_t& cid); - using omap_set_kvs_ret = tm_ertr::future<>; + using omap_set_kvs_ret = tm_iertr::future<>; omap_set_kvs_ret _omap_set_kvs( const omap_root_le_t& omap_root, Transaction& t, diff --git a/src/crimson/os/seastore/segment_cleaner.cc b/src/crimson/os/seastore/segment_cleaner.cc index 41ac9e86aba0..f2e43273152c 100644 --- a/src/crimson/os/seastore/segment_cleaner.cc +++ b/src/crimson/os/seastore/segment_cleaner.cc @@ -281,20 +281,15 @@ SegmentCleaner::gc_cycle_ret SegmentCleaner::do_gc_cycle() SegmentCleaner::gc_trim_journal_ret SegmentCleaner::gc_trim_journal() { - return repeat_eagain( - [this] { - return seastar::do_with( - ecb->create_transaction(Transaction::src_t::CLEANER), - [this](auto &tref) { - return with_trans_intr(*tref, [this](auto &t) { - return rewrite_dirty(t, get_dirty_tail() - ).si_then([this, &t] { - return ecb->submit_transaction_direct( - t); - }); - }); - }); + return repeat_eagain([this] { + return ecb->with_transaction_intr( + Transaction::src_t::CLEANER, [this](auto& t) { + return rewrite_dirty(t, get_dirty_tail() + ).si_then([this, &t] { + return ecb->submit_transaction_direct(t); + }); }); + }); } SegmentCleaner::gc_reclaim_space_ret SegmentCleaner::gc_reclaim_space() @@ -323,56 +318,53 @@ SegmentCleaner::gc_reclaim_space_ret SegmentCleaner::gc_reclaim_space() config.reclaim_bytes_stride ).safe_then([this](auto &&_extents) { return seastar::do_with( - std::move(_extents), - [this](auto &extents) { - return repeat_eagain([this, &extents]() mutable { - logger().debug( - "SegmentCleaner::gc_reclaim_space: processing {} extents", - extents.size()); - return seastar::do_with( - ecb->create_transaction(Transaction::src_t::CLEANER), - [this, &extents](auto &tref) mutable { - return with_trans_intr(*tref, [this, &extents](auto &t) { - return trans_intr::do_for_each( - extents, - [this, &t](auto &extent) { - auto &[addr, info] = extent; - logger().debug( - "SegmentCleaner::gc_reclaim_space: checking extent {}", - info); - return ecb->get_extent_if_live( - t, - info.type, - addr, - info.addr, - info.len - ).si_then([addr=addr, &t, this](CachedExtentRef ext) { - if (!ext) { - logger().debug( - "SegmentCleaner::gc_reclaim_space: addr {} dead, skipping", - addr); - return ExtentCallbackInterface::rewrite_extent_iertr::now(); - } else { - logger().debug( - "SegmentCleaner::gc_reclaim_space: addr {} alive, gc'ing {}", - addr, - *ext); - return ecb->rewrite_extent( - t, - ext); - } - }); - } - ).si_then([this, &t] { - if (scan_cursor->is_complete()) { - t.mark_segment_to_release(scan_cursor->get_offset().segment); - } - return ecb->submit_transaction_direct(t); - }); - }); - }); - }); + std::move(_extents), + [this](auto &extents) { + return repeat_eagain([this, &extents]() mutable { + logger().debug( + "SegmentCleaner::gc_reclaim_space: processing {} extents", + extents.size()); + return ecb->with_transaction_intr( + Transaction::src_t::CLEANER, + [this, &extents](auto& t) { + return trans_intr::do_for_each( + extents, + [this, &t](auto &extent) { + auto &[addr, info] = extent; + logger().debug( + "SegmentCleaner::gc_reclaim_space: checking extent {}", + info); + return ecb->get_extent_if_live( + t, + info.type, + addr, + info.addr, + info.len + ).si_then([addr=addr, &t, this](CachedExtentRef ext) { + if (!ext) { + logger().debug( + "SegmentCleaner::gc_reclaim_space: addr {} dead, skipping", + addr); + return ExtentCallbackInterface::rewrite_extent_iertr::now(); + } else { + logger().debug( + "SegmentCleaner::gc_reclaim_space: addr {} alive, gc'ing {}", + addr, + *ext); + return ecb->rewrite_extent( + t, + ext); + } + }); + }).si_then([this, &t] { + if (scan_cursor->is_complete()) { + t.mark_segment_to_release(scan_cursor->get_offset().segment); + } + return ecb->submit_transaction_direct(t); + }); + }); }); + }); }).safe_then([this] { if (scan_cursor->is_complete()) { scan_cursor.reset(); diff --git a/src/crimson/os/seastore/segment_cleaner.h b/src/crimson/os/seastore/segment_cleaner.h index b656abb59494..a04a0bbf3796 100644 --- a/src/crimson/os/seastore/segment_cleaner.h +++ b/src/crimson/os/seastore/segment_cleaner.h @@ -248,6 +248,22 @@ public: virtual TransactionRef create_transaction(Transaction::src_t) = 0; + /// Creates empty transaction with interruptible context + template + auto with_transaction_intr(Transaction::src_t src, Func &&f) { + return seastar::do_with( + create_transaction(src), + [f=std::forward(f)](auto &ref_t) mutable { + return with_trans_intr( + *ref_t, + [f=std::forward(f)](auto& t) mutable { + return f(t); + } + ); + } + ); + } + /** * get_next_dirty_extent * diff --git a/src/crimson/os/seastore/transaction.h b/src/crimson/os/seastore/transaction.h index e01f01a88303..b34a314343dd 100644 --- a/src/crimson/os/seastore/transaction.h +++ b/src/crimson/os/seastore/transaction.h @@ -160,6 +160,10 @@ public: return weak; } + void test_set_conflict() { + conflicted = true; + } + bool is_conflicted() const { return conflicted; } diff --git a/src/crimson/os/seastore/transaction_manager.cc b/src/crimson/os/seastore/transaction_manager.cc index f0e6b99243e8..de87f053ba47 100644 --- a/src/crimson/os/seastore/transaction_manager.cc +++ b/src/crimson/os/seastore/transaction_manager.cc @@ -35,32 +35,24 @@ TransactionManager::mkfs_ertr::future<> TransactionManager::mkfs() return journal->open_for_write().safe_then([this, FNAME](auto addr) { DEBUG("about to do_with"); segment_cleaner->init_mkfs(addr); - return seastar::do_with( - create_transaction(Transaction::src_t::INIT), - [this, FNAME](auto &transaction) { - DEBUGT( - "about to cache->mkfs", - *transaction); - cache->init(); - return cache->mkfs(*transaction - ).safe_then([this, &transaction] { - return lba_manager->mkfs(*transaction); - }).safe_then([this, FNAME, &transaction] { - DEBUGT("about to submit_transaction", *transaction); - return with_trans_intr( - *transaction, - [this, &transaction](auto&) { - return submit_transaction_direct(*transaction); - } - ).handle_error( - crimson::ct_error::eagain::handle([] { - ceph_assert(0 == "eagain impossible"); - return mkfs_ertr::now(); - }), - mkfs_ertr::pass_further{} - ); - }); + return with_transaction_intr( + Transaction::src_t::INIT, [this, FNAME](auto& t) { + DEBUGT("about to cache->mkfs", t); + cache->init(); + return cache->mkfs(t + ).si_then([this, &t] { + return lba_manager->mkfs(t); + }).si_then([this, FNAME, &t] { + DEBUGT("about to submit_transaction", t); + return submit_transaction_direct(t); }); + }).handle_error( + crimson::ct_error::eagain::handle([] { + ceph_assert(0 == "eagain impossible"); + return mkfs_ertr::now(); + }), + mkfs_ertr::pass_further{} + ); }).safe_then([this] { return close(); }); diff --git a/src/crimson/os/seastore/transaction_manager.h b/src/crimson/os/seastore/transaction_manager.h index 5755ac3fdd10..df21268819ec 100644 --- a/src/crimson/os/seastore/transaction_manager.h +++ b/src/crimson/os/seastore/transaction_manager.h @@ -53,29 +53,6 @@ auto repeat_eagain(F &&f) { }); } -// non-errorated version -template -auto repeat_eagain2(F &&f) { - LOG_PREFIX("repeat_eagain"); - return seastar::do_with( - std::forward(f), - [FNAME](auto &f) { - return seastar::repeat( - [FNAME, &f] { - return std::invoke(f - ).safe_then([] { - return seastar::stop_iteration::yes; - }).handle_error( - [FNAME](const crimson::ct_error::eagain &e) { - DEBUG("hit eagain, restarting"); - return seastar::make_ready_future( - seastar::stop_iteration::no); - } - ); - }); - }); -} - /** * TransactionManager * @@ -128,7 +105,6 @@ public: * * Get the logical pin at offset */ - using get_pin_ertr = LBAManager::get_mapping_ertr; using get_pin_iertr = LBAManager::get_mapping_iertr; using get_pin_ret = LBAManager::get_mapping_iertr::future; get_pin_ret get_pin( diff --git a/src/crimson/tools/store_nbd/tm_driver.cc b/src/crimson/tools/store_nbd/tm_driver.cc index 47f450bb0021..e5c19a70ade2 100644 --- a/src/crimson/tools/store_nbd/tm_driver.cc +++ b/src/crimson/tools/store_nbd/tm_driver.cc @@ -21,31 +21,27 @@ seastar::future<> TMDriver::write( logger().debug("Writing offset {}", offset); assert(offset % segment_manager->get_block_size() == 0); assert((ptr.length() % (size_t)segment_manager->get_block_size()) == 0); - return repeat_eagain([this, offset, ptr=std::move(ptr)] { - return seastar::do_with( - tm->create_transaction(Transaction::src_t::MUTATE), - ptr, - [this, offset](auto &t, auto &ptr) mutable { - return tm->dec_ref( - *t, - offset - ).safe_then([](auto){}).handle_error( - crimson::ct_error::enoent::handle([](auto) { return seastar::now(); }), - crimson::ct_error::pass_further_all{} - ).safe_then([=, &t, &ptr] { - logger().debug("dec_ref complete"); - return tm->alloc_extent( - *t, - offset, - ptr.length()); - }).safe_then([=, &t, &ptr](auto ext) mutable { - assert(ext->get_laddr() == (size_t)offset); - assert(ext->get_bptr().length() == ptr.length()); - ext->get_bptr().swap(ptr); - logger().debug("submitting transaction"); - return tm->submit_transaction(*t); - }); + return seastar::do_with(ptr, [this, offset](auto& ptr) { + return repeat_eagain([this, offset, &ptr] { + return tm->with_transaction_intr( + Transaction::src_t::MUTATE, + [this, offset, &ptr](auto& t) { + return tm->dec_ref(t, offset + ).si_then([](auto){}).handle_error_interruptible( + crimson::ct_error::enoent::handle([](auto) { return seastar::now(); }), + crimson::ct_error::pass_further_all{} + ).si_then([this, offset, &t, &ptr] { + logger().debug("dec_ref complete"); + return tm->alloc_extent(t, offset, ptr.length()); + }).si_then([this, offset, &t, &ptr](auto ext) { + assert(ext->get_laddr() == (size_t)offset); + assert(ext->get_bptr().length() == ptr.length()); + ext->get_bptr().swap(ptr); + logger().debug("submitting transaction"); + return tm->submit_transaction(t); + }); }); + }); }).handle_error( crimson::ct_error::assert_all{"store-nbd write"} ); @@ -62,10 +58,10 @@ TMDriver::read_extents_ret TMDriver::read_extents( [this, &t, offset, length](auto &pins, auto &ret) { return tm->get_pins( t, offset, length - ).safe_then([this, &t, &pins, &ret](auto _pins) { + ).si_then([this, &t, &pins, &ret](auto _pins) { _pins.swap(pins); logger().debug("read_extents: mappings {}", pins); - return crimson::do_for_each( + return trans_intr::do_for_each( pins.begin(), pins.end(), [this, &t, &ret](auto &&pin) { @@ -76,14 +72,14 @@ TMDriver::read_extents_ret TMDriver::read_extents( return tm->pin_to_extent( t, std::move(pin) - ).safe_then([this, &ret](auto ref) mutable { + ).si_then([this, &ret](auto ref) mutable { ret.push_back(std::make_pair(ref->get_laddr(), ref)); logger().debug( "read_extents: got extent {}", *ref); return seastar::now(); }); - }).safe_then([&ret] { + }).si_then([&ret] { return std::move(ret); }); }); @@ -100,27 +96,27 @@ seastar::future TMDriver::read( auto blptrret = std::make_unique(); auto &blret = *blptrret; return repeat_eagain([=, &blret] { - return seastar::do_with( - tm->create_transaction(Transaction::src_t::READ), - [=, &blret](auto &t) { - return read_extents(*t, offset, size - ).safe_then([=, &blret](auto ext_list) mutable { - size_t cur = offset; - for (auto &i: ext_list) { - if (cur != i.first) { - assert(cur < i.first); - blret.append_zero(i.first - cur); - cur = i.first; - } - blret.append(i.second->get_bptr()); - cur += i.second->get_bptr().length(); - } - if (blret.length() != size) { - assert(blret.length() < size); - blret.append_zero(size - blret.length()); - } - }); + return tm->with_transaction_intr( + Transaction::src_t::READ, + [=, &blret](auto& t) { + return read_extents(t, offset, size + ).si_then([=, &blret](auto ext_list) { + size_t cur = offset; + for (auto &i: ext_list) { + if (cur != i.first) { + assert(cur < i.first); + blret.append_zero(i.first - cur); + cur = i.first; + } + blret.append(i.second->get_bptr()); + cur += i.second->get_bptr().length(); + } + if (blret.length() != size) { + assert(blret.length() < size); + blret.append_zero(size - blret.length()); + } }); + }); }).handle_error( crimson::ct_error::assert_all{"store-nbd read"} ).then([blptrret=std::move(blptrret)]() mutable { @@ -141,7 +137,7 @@ void TMDriver::init() journal->set_segment_provider(&*segment_cleaner); - tm = InterruptedTMRef( + tm = std::make_unique( *segment_manager, std::move(segment_cleaner), std::move(journal), diff --git a/src/crimson/tools/store_nbd/tm_driver.h b/src/crimson/tools/store_nbd/tm_driver.h index 3fb83c3e68b7..c0e1fc480468 100644 --- a/src/crimson/tools/store_nbd/tm_driver.h +++ b/src/crimson/tools/store_nbd/tm_driver.h @@ -40,16 +40,15 @@ private: std::unique_ptr segment_manager; using TransactionManager = crimson::os::seastore::TransactionManager; - using TMRef = crimson::os::seastore::InterruptedTMRef; - TMRef tm; + using TransactionManagerRef = crimson::os::seastore::TransactionManagerRef; + TransactionManagerRef tm; seastar::future<> mkfs(); void init(); void clear(); - using read_extents_ertr = crimson::os::seastore::with_trans_ertr< - TransactionManager::read_extent_iertr>; - using read_extents_ret = read_extents_ertr::future< + using read_extents_iertr = TransactionManager::read_extent_iertr; + using read_extents_ret = read_extents_iertr::future< crimson::os::seastore::lextent_list_t >; read_extents_ret read_extents( diff --git a/src/test/crimson/seastore/onode_tree/test_fltree_onode_manager.cc b/src/test/crimson/seastore/onode_tree/test_fltree_onode_manager.cc index c41fe6df770d..80122d9eb427 100644 --- a/src/test/crimson/seastore/onode_tree/test_fltree_onode_manager.cc +++ b/src/test/crimson/seastore/onode_tree/test_fltree_onode_manager.cc @@ -86,10 +86,12 @@ struct fltree_onode_manager_test_t ).safe_then([this] { return seastar::do_with( create_mutate_transaction(), - [this](auto &t) { - return manager->mkfs(*t - ).safe_then([this, &t] { - return submit_transaction_fut(*t); + [this](auto &ref_t) { + return with_trans_intr(*ref_t, [&](auto &t) { + return manager->mkfs(t + ).si_then([this, &t] { + return submit_transaction_fut(t); + }); }); }); }).safe_then([this] { diff --git a/src/test/crimson/seastore/onode_tree/test_staged_fltree.cc b/src/test/crimson/seastore/onode_tree/test_staged_fltree.cc index ac23d040ddc1..24e314fb1d17 100644 --- a/src/test/crimson/seastore/onode_tree/test_staged_fltree.cc +++ b/src/test/crimson/seastore/onode_tree/test_staged_fltree.cc @@ -213,7 +213,7 @@ struct b_dummy_tree_test_t : public seastar_test_suite_t { tree{std::move(moved_nm)} {} seastar::future<> set_up_fut() override final { - return tree.mkfs(t).handle_error( + return INTR(tree.mkfs, t).handle_error( crimson::ct_error::all_same_way([] { ASSERT_FALSE("Unable to mkfs"); }) @@ -479,7 +479,7 @@ class TestTree { std::pair range_0, size_t value_size) { return seastar::async([this, range_2, range_1, range_0, value_size] { - tree.mkfs(t).unsafe_get0(); + INTR(tree.mkfs, t).unsafe_get0(); //logger().info("\n---------------------------------------------" // "\nbefore leaf node split:\n"); auto keys = build_key_set(range_2, range_1, range_0); @@ -498,7 +498,7 @@ class TestTree { seastar::future<> build_tree( const std::vector& keys, const std::vector& values) { return seastar::async([this, keys, values] { - tree.mkfs(t).unsafe_get0(); + INTR(tree.mkfs, t).unsafe_get0(); //logger().info("\n---------------------------------------------" // "\nbefore leaf node split:\n"); ASSERT_EQ(keys.size(), values.size()); @@ -1129,7 +1129,7 @@ class DummyChildPool { DummyChildPool() = default; ~DummyChildPool() { reset(); } - eagain_future<> build_tree(const std::set& keys) { + auto build_tree(const std::set& keys) { reset(); // create tree auto ref_dummy = NodeExtentManager::create_dummy(IS_DUMMY_SYNC); @@ -1740,12 +1740,12 @@ TEST_F(d_seastore_tm_test_t, 7_tree_insert_erase_eagain) auto iter = kvs.begin(); while (iter != kvs.end()) { ++num_ops; - repeat_eagain2([this, &tree, &num_ops_eagain, &iter] { + repeat_eagain([this, &tree, &num_ops_eagain, &iter] { ++num_ops_eagain; auto t = create_read_transaction(); return INTR_R(tree->validate_one, *t, iter ).safe_then([t=std::move(t)]{}); - }).get0(); + }).unsafe_get0(); ++iter; } } diff --git a/src/test/crimson/seastore/test_btree_lba_manager.cc b/src/test/crimson/seastore/test_btree_lba_manager.cc index 57f575c17227..144922969b8b 100644 --- a/src/test/crimson/seastore/test_btree_lba_manager.cc +++ b/src/test/crimson/seastore/test_btree_lba_manager.cc @@ -74,13 +74,15 @@ struct btree_lba_manager_test : }).safe_then([this](auto addr) { return seastar::do_with( cache.create_transaction(Transaction::src_t::MUTATE), - [this](auto &transaction) { - cache.init(); - return cache.mkfs(*transaction - ).safe_then([this, &transaction] { - return lba_manager->mkfs(*transaction); - }).safe_then([this, &transaction] { - return submit_transaction(std::move(transaction)); + [this](auto &ref_t) { + return with_trans_intr(*ref_t, [&](auto &t) { + cache.init(); + return cache.mkfs(t + ).si_then([this, &t] { + return lba_manager->mkfs(t); + }); + }).safe_then([this, &ref_t] { + return submit_transaction(std::move(ref_t)); }); }); }).handle_error( diff --git a/src/test/crimson/seastore/test_seastore_cache.cc b/src/test/crimson/seastore/test_seastore_cache.cc index d53e0df79040..f93bbf3e89fd 100644 --- a/src/test/crimson/seastore/test_seastore_cache.cc +++ b/src/test/crimson/seastore/test_seastore_cache.cc @@ -77,23 +77,23 @@ struct cache_test_t : public seastar_test_suite_t { seastar::future<> set_up_fut() final { return segment_manager->init( - ).safe_then( - [this] { - return seastar::do_with( - get_transaction(), - [this](auto &transaction) { - cache.init(); - return cache.mkfs(*transaction).safe_then( - [this, &transaction] { - return submit_transaction(std::move(transaction)).then( - [](auto p) {}); - }); - }); - }).handle_error( - crimson::ct_error::all_same_way([](auto e) { - ASSERT_FALSE("failed to submit"); - }) - ); + ).safe_then([this] { + return seastar::do_with( + get_transaction(), + [this](auto &ref_t) { + cache.init(); + return with_trans_intr(*ref_t, [&](auto &t) { + return cache.mkfs(t); + }).safe_then([this, &ref_t] { + return submit_transaction(std::move(ref_t) + ).then([](auto p) {}); + }); + }); + }).handle_error( + crimson::ct_error::all_same_way([](auto e) { + ASSERT_FALSE("failed to submit"); + }) + ); } seastar::future<> tear_down_fut() final {