namespace crimson::os::seastore::omap_manager {
-OMapManagerRef create_omap_manager(
- InterruptedTransactionManager trans_manager) {
+OMapManagerRef create_omap_manager(TransactionManager &trans_manager) {
return OMapManagerRef(new BtreeOMapManager(trans_manager));
}
* until these functions future resolved.
*/
public:
- using base_ertr = with_trans_ertr<TransactionManager::base_iertr>;
+ using base_iertr = TransactionManager::base_iertr;
/**
* allocate omap tree root node
* @param Transaction &t, current transaction
* @retval return the omap_root_t structure.
*/
- using initialize_omap_ertr = base_ertr;
- using initialize_omap_ret = initialize_omap_ertr::future<omap_root_t>;
+ using initialize_omap_iertr = base_iertr;
+ using initialize_omap_ret = initialize_omap_iertr::future<omap_root_t>;
virtual initialize_omap_ret initialize_omap(Transaction &t) = 0;
/**
* @param string &key, omap string key
* @retval return string key->string value mapping pair.
*/
- using omap_get_value_ertr = base_ertr;
- using omap_get_value_ret = omap_get_value_ertr::future<
+ using omap_get_value_iertr = base_iertr;
+ using omap_get_value_ret = omap_get_value_iertr::future<
std::optional<bufferlist>>;
virtual omap_get_value_ret omap_get_value(
const omap_root_t &omap_root,
* @param string &key, omap string key
* @param string &value, mapped value corresponding key
*/
- using omap_set_key_ertr = base_ertr;
- using omap_set_key_ret = omap_set_key_ertr::future<>;
+ using omap_set_key_iertr = base_iertr;
+ using omap_set_key_ret = omap_set_key_iertr::future<>;
virtual omap_set_key_ret omap_set_key(
omap_root_t &omap_root,
Transaction &t,
const std::string &key,
const ceph::bufferlist &value) = 0;
- using omap_set_keys_ertr = base_ertr;
- using omap_set_keys_ret = omap_set_keys_ertr::future<>;
+ using omap_set_keys_iertr = base_iertr;
+ using omap_set_keys_ret = omap_set_keys_iertr::future<>;
virtual omap_set_keys_ret omap_set_keys(
omap_root_t &omap_root,
Transaction &t,
* @param Transaction &t, current transaction
* @param string &key, omap string key
*/
- using omap_rm_key_ertr = base_ertr;
- using omap_rm_key_ret = omap_rm_key_ertr::future<>;
+ using omap_rm_key_iertr = base_iertr;
+ using omap_rm_key_ret = omap_rm_key_iertr::future<>;
virtual omap_rm_key_ret omap_rm_key(
omap_root_t &omap_root,
Transaction &t,
);
}
};
- using omap_list_ertr = base_ertr;
+ using omap_list_iertr = base_iertr;
using omap_list_bare_ret = std::tuple<
bool,
std::map<std::string, bufferlist, std::less<>>>;
- using omap_list_ret = omap_list_ertr::future<omap_list_bare_ret>;
+ using omap_list_ret = omap_list_iertr::future<omap_list_bare_ret>;
virtual omap_list_ret omap_list(
const omap_root_t &omap_root,
Transaction &t,
* @param omap_root_t &omap_root, omap btree root information
* @param Transaction &t, current transaction
*/
- using omap_clear_ertr = base_ertr;
- using omap_clear_ret = omap_clear_ertr::future<>;
+ using omap_clear_iertr = base_iertr;
+ using omap_clear_ret = omap_clear_iertr::future<>;
virtual omap_clear_ret omap_clear(omap_root_t &omap_root, Transaction &t) = 0;
virtual ~OMapManager() {}
namespace omap_manager {
OMapManagerRef create_omap_manager (
- InterruptedTransactionManager trans_manager);
+ TransactionManager &trans_manager);
}
}
TransactionManager &tm)
: tm(tm) {}
-BtreeOMapManager::BtreeOMapManager(
- InterruptedTransactionManager tm)
- : tm(tm) {}
-
BtreeOMapManager::initialize_omap_ret
BtreeOMapManager::initialize_omap(Transaction &t)
{
logger().debug("{}", __func__);
return tm.alloc_extent<OMapLeafNode>(t, L_ADDR_MIN, OMAP_BLOCK_SIZE)
- .safe_then([](auto&& root_extent) {
+ .si_then([](auto&& root_extent) {
root_extent->set_size(0);
omap_node_meta_t meta{1};
root_extent->set_meta(meta);
omap_root_t omap_root;
omap_root.update(root_extent->get_laddr(), 1);
- return initialize_omap_ertr::make_ready_future<omap_root_t>(omap_root);
+ return initialize_omap_iertr::make_ready_future<omap_root_t>(omap_root);
});
}
const OMapNode::mutation_result_t& mresult)
{
return oc.tm.alloc_extent<OMapInnerNode>(oc.t, L_ADDR_MIN, OMAP_BLOCK_SIZE)
- .safe_then([&omap_root, mresult](auto&& nroot) -> handle_root_split_ret {
+ .si_then([&omap_root, mresult](auto&& nroot) -> handle_root_split_ret {
auto [left, right, pivot] = *(mresult.split_tuple);
omap_node_meta_t meta{omap_root.depth + 1};
nroot->set_meta(meta);
iter->get_val(),
omap_root.depth -= 1);
return oc.tm.dec_ref(oc.t, root->get_laddr()
- ).safe_then([](auto &&ret) -> handle_root_merge_ret {
+ ).si_then([](auto &&ret) -> handle_root_merge_ret {
return seastar::now();
- }).handle_error(
- handle_root_merge_ertr::pass_further{},
+ }).handle_error_interruptible(
+ handle_root_merge_iertr::pass_further{},
crimson::ct_error::assert_all{
"Invalid error in handle_root_merge"
}
return get_omap_root(
get_omap_context(t),
omap_root
- ).safe_then([this, &t, &key](auto&& extent) {
+ ).si_then([this, &t, &key](auto&& extent) {
return extent->get_value(get_omap_context(t), key);
- }).safe_then([](auto &&e) {
+ }).si_then([](auto &&e) {
return omap_get_value_ret(
- omap_get_value_ertr::ready_future_marker{},
+ interruptible::ready_future_marker{},
std::move(e));
});
}
std::map<std::string, ceph::bufferlist>&& keys)
{
return seastar::do_with(std::move(keys), [&, this](auto& keys) {
- return crimson::do_for_each(
+ return trans_intr::do_for_each(
keys.begin(),
keys.end(),
[&, this](auto &p) {
return get_omap_root(
get_omap_context(t),
omap_root
- ).safe_then([this, &t, &key, &value](auto root) {
+ ).si_then([this, &t, &key, &value](auto root) {
return root->insert(get_omap_context(t), key, value);
- }).safe_then([this, &omap_root, &t](auto mresult) -> omap_set_key_ret {
+ }).si_then([this, &omap_root, &t](auto mresult) -> omap_set_key_ret {
if (mresult.status == mutation_status_t::SUCCESS)
return seastar::now();
else if (mresult.status == mutation_status_t::WAS_SPLIT)
return get_omap_root(
get_omap_context(t),
omap_root
- ).safe_then([this, &t, &key](auto root) {
+ ).si_then([this, &t, &key](auto root) {
return root->rm_key(get_omap_context(t), key);
- }).safe_then([this, &omap_root, &t](auto mresult) -> omap_rm_key_ret {
+ }).si_then([this, &omap_root, &t](auto mresult) -> omap_rm_key_ret {
if (mresult.status == mutation_status_t::SUCCESS) {
return seastar::now();
} else if (mresult.status == mutation_status_t::WAS_SPLIT) {
return get_omap_root(
get_omap_context(t),
omap_root
- ).safe_then([this, config, &t, &start](auto extent) {
+ ).si_then([this, config, &t, &start](auto extent) {
return extent->list(
get_omap_context(t),
start,
return get_omap_root(
get_omap_context(t),
omap_root
- ).safe_then([this, &t](auto extent) {
+ ).si_then([this, &t](auto extent) {
return extent->clear(get_omap_context(t));
- }).safe_then([this, &omap_root, &t] {
+ }).si_then([this, &omap_root, &t] {
return tm.dec_ref(
t, omap_root.get_location()
- ).safe_then([&omap_root] (auto ret) {
+ ).si_then([&omap_root] (auto ret) {
omap_root.update(
L_ADDR_NULL,
0);
- return omap_clear_ertr::now();
+ return omap_clear_iertr::now();
});
- }).handle_error(
- omap_clear_ertr::pass_further{},
+ }).handle_error_interruptible(
+ omap_clear_iertr::pass_further{},
crimson::ct_error::assert_all{
"Invalid error in BtreeOMapManager::omap_clear"
}
*/
class BtreeOMapManager : public OMapManager {
- InterruptedTransactionManager tm;
+ TransactionManager &tm;
omap_context_t get_omap_context(
Transaction &t) {
*
* load omap tree root node
*/
- using get_root_ertr = base_ertr;
- using get_root_ret = get_root_ertr::future<OMapNodeRef>;
+ using get_root_iertr = base_iertr;
+ using get_root_ret = get_root_iertr::future<OMapNodeRef>;
static get_root_ret get_omap_root(
omap_context_t c,
const omap_root_t &omap_root);
*
* root has been split and needs to update omap_root_t
*/
- using handle_root_split_ertr = base_ertr;
- using handle_root_split_ret = handle_root_split_ertr::future<>;
+ using handle_root_split_iertr = base_iertr;
+ using handle_root_split_ret = handle_root_split_iertr::future<>;
handle_root_split_ret handle_root_split(
omap_context_t c,
omap_root_t &omap_root,
*
* root node has only one item and it is not leaf node, need remove a layer
*/
- using handle_root_merge_ertr = base_ertr;
- using handle_root_merge_ret = handle_root_merge_ertr::future<>;
+ using handle_root_merge_iertr = base_iertr;
+ using handle_root_merge_ret = handle_root_merge_iertr::future<>;
handle_root_merge_ret handle_root_merge(
omap_context_t oc,
omap_root_t &omap_root,
OMapNode:: mutation_result_t mresult);
public:
- explicit BtreeOMapManager(InterruptedTransactionManager tm);
explicit BtreeOMapManager(TransactionManager &tm);
initialize_omap_ret initialize_omap(Transaction &t) final;
namespace crimson::os::seastore::omap_manager{
struct omap_context_t {
- InterruptedTransactionManager tm;
+ TransactionManager &tm;
Transaction &t;
};
};
struct OMapNode : LogicalCachedExtent {
- using base_ertr = OMapManager::base_ertr;
+ using base_iertr = OMapManager::base_iertr;
using OMapNodeRef = TCachedExtentRef<OMapNode>;
OMapNode(const OMapNode &other)
: LogicalCachedExtent(other) {}
- using get_value_ertr = base_ertr;
+ using get_value_iertr = base_iertr;
using get_value_ret = OMapManager::omap_get_value_ret;
virtual get_value_ret get_value(
omap_context_t oc,
const std::string &key) = 0;
- using insert_ertr = base_ertr;
- using insert_ret = insert_ertr::future<mutation_result_t>;
+ using insert_iertr = base_iertr;
+ using insert_ret = insert_iertr::future<mutation_result_t>;
virtual insert_ret insert(
omap_context_t oc,
const std::string &key,
const ceph::bufferlist &value) = 0;
- using rm_key_ertr = base_ertr;
- using rm_key_ret = rm_key_ertr::future<mutation_result_t>;
+ using rm_key_iertr = base_iertr;
+ using rm_key_ret = rm_key_iertr::future<mutation_result_t>;
virtual rm_key_ret rm_key(
omap_context_t oc,
const std::string &key) = 0;
using omap_list_config_t = OMapManager::omap_list_config_t;
- using list_ertr = base_ertr;
+ using list_iertr = base_iertr;
using list_bare_ret = OMapManager::omap_list_bare_ret;
using list_ret = OMapManager::omap_list_ret;
virtual list_ret list(
const std::optional<std::string> &start,
omap_list_config_t config) = 0;
- using clear_ertr = base_ertr;
- using clear_ret = clear_ertr::future<>;
+ using clear_iertr = base_iertr;
+ using clear_ret = clear_iertr::future<>;
virtual clear_ret clear(omap_context_t oc) = 0;
- using full_merge_ertr = base_ertr;
- using full_merge_ret = full_merge_ertr::future<OMapNodeRef>;
+ using full_merge_iertr = base_iertr;
+ using full_merge_ret = full_merge_iertr::future<OMapNodeRef>;
virtual full_merge_ret make_full_merge(
omap_context_t oc,
OMapNodeRef right) = 0;
- using make_balanced_ertr = base_ertr;
- using make_balanced_ret = make_balanced_ertr::future
+ using make_balanced_iertr = base_iertr;
+ using make_balanced_ret = make_balanced_iertr::future
<std::tuple<OMapNodeRef, OMapNodeRef, std::string>>;
virtual make_balanced_ret make_balanced(
omap_context_t oc,
using OMapNodeRef = OMapNode::OMapNodeRef;
-using omap_load_extent_ertr = OMapNode::base_ertr;
-omap_load_extent_ertr::future<OMapNodeRef>
+using omap_load_extent_iertr = OMapNode::base_iertr;
+omap_load_extent_iertr::future<OMapNodeRef>
omap_load_extent(omap_context_t oc, laddr_t laddr, depth_t depth);
}
<< ", depth=" << get_meta().depth;
}
-using dec_ref_ertr = OMapInnerNode::base_ertr;
-using dec_ref_ret = dec_ref_ertr::future<>;
+using dec_ref_iertr = OMapInnerNode::base_iertr;
+using dec_ref_ret = dec_ref_iertr::future<>;
template <typename T>
dec_ref_ret dec_ref(omap_context_t oc, T&& addr) {
- return oc.tm.dec_ref(oc.t, std::forward<T>(addr)).handle_error(
- dec_ref_ertr::pass_further{},
+ return oc.tm.dec_ref(oc.t, std::forward<T>(addr)).handle_error_interruptible(
+ dec_ref_iertr::pass_further{},
crimson::ct_error::assert_all{
"Invalid error in OMapInnerNode helper dec_ref"
}
- ).safe_then([](auto &&e) {});
+ ).si_then([](auto &&e) {});
}
/**
std::string key,
laddr_t laddr)
{
- return make_split_children(oc).safe_then([=] (auto tuple) {
+ return make_split_children(oc).si_then([=] (auto tuple) {
auto [left, right, pivot] = tuple;
if (pivot > key) {
auto liter = left->iter_idx(iter.get_index());
right->maybe_get_delta_buffer());
}
return make_split_insert_ret(
- make_split_insert_ertr::ready_future_marker{},
+ interruptible::ready_future_marker{},
mutation_result_t(mutation_status_t::WAS_SPLIT, tuple, std::nullopt));
});
journal_inner_insert(iter + 1, right->get_laddr(), pivot,
maybe_get_delta_buffer());
return insert_ret(
- insert_ertr::ready_future_marker{},
+ interruptible::ready_future_marker{},
mutation_result_t(mutation_status_t::SUCCESS, std::nullopt, std::nullopt));
} else {
return make_split_insert(oc, iter + 1, pivot, right->get_laddr())
- .safe_then([this, oc] (auto m_result) {
+ .si_then([this, oc] (auto m_result) {
return dec_ref(oc, get_laddr())
- .safe_then([m_result = std::move(m_result)] {
+ .si_then([m_result = std::move(m_result)] {
return insert_ret(
- insert_ertr::ready_future_marker{},
+ interruptible::ready_future_marker{},
m_result);
});
});
auto child_pt = get_containing_child(key);
assert(child_pt != iter_end());
auto laddr = child_pt->get_val();
- return omap_load_extent(oc, laddr, get_meta().depth - 1).safe_then(
+ return omap_load_extent(oc, laddr, get_meta().depth - 1).si_then(
[oc, &key] (auto extent) {
return extent->get_value(oc, key);
}).finally([ref = OMapNodeRef(this)] {});
auto child_pt = get_containing_child(key);
assert(child_pt != iter_end());
auto laddr = child_pt->get_val();
- return omap_load_extent(oc, laddr, get_meta().depth - 1).safe_then(
+ return omap_load_extent(oc, laddr, get_meta().depth - 1).si_then(
[oc, &key, &value] (auto extent) {
return extent->insert(oc, key, value);
- }).safe_then([this, oc, child_pt] (auto mresult) {
+ }).si_then([this, oc, child_pt] (auto mresult) {
if (mresult.status == mutation_status_t::SUCCESS) {
- return insert_ertr::make_ready_future<mutation_result_t>(mresult);
+ return insert_iertr::make_ready_future<mutation_result_t>(mresult);
} else if (mresult.status == mutation_status_t::WAS_SPLIT) {
return handle_split(oc, child_pt, mresult);
} else {
return insert_ret(
- insert_ertr::ready_future_marker{},
+ interruptible::ready_future_marker{},
mutation_result_t(mutation_status_t::SUCCESS, std::nullopt, std::nullopt));
}
});
auto child_pt = get_containing_child(key);
assert(child_pt != iter_end());
auto laddr = child_pt->get_val();
- return omap_load_extent(oc, laddr, get_meta().depth - 1).safe_then(
+ return omap_load_extent(oc, laddr, get_meta().depth - 1).si_then(
[this, oc, &key, child_pt] (auto extent) {
return extent->rm_key(oc, key)
- .safe_then([this, oc, child_pt, extent = std::move(extent)] (auto mresult) {
+ .si_then([this, oc, child_pt, extent = std::move(extent)] (auto mresult) {
switch (mresult.status) {
case mutation_status_t::SUCCESS:
case mutation_status_t::FAIL:
- return rm_key_ertr::make_ready_future<mutation_result_t>(mresult);
+ return rm_key_iertr::make_ready_future<mutation_result_t>(mresult);
case mutation_status_t::NEED_MERGE: {
if (get_node_size() >1)
return merge_entry(oc, child_pt, *(mresult.need_merge));
else
return rm_key_ret(
- rm_key_ertr::ready_future_marker{},
+ interruptible::ready_future_marker{},
mutation_result_t(mutation_status_t::SUCCESS,
std::nullopt, std::nullopt));
}
case mutation_status_t::WAS_SPLIT:
return handle_split(oc, child_pt, mresult);
default:
- return rm_key_ertr::make_ready_future<mutation_result_t>(mresult);
+ return rm_key_iertr::make_ready_future<mutation_result_t>(mresult);
}
});
});
[=, &start](auto &biter, auto &eiter, auto &ret) {
auto &complete = std::get<0>(ret);
auto &result = std::get<1>(ret);
- return crimson::repeat(
- [&, config, oc, this]() -> list_ertr::future<seastar::stop_iteration> {
+ return trans_intr::repeat(
+ [&, config, oc, this]() -> list_iertr::future<seastar::stop_iteration> {
if (biter == eiter || result.size() == config.max_result_size) {
complete = biter == eiter;
- return list_ertr::make_ready_future<seastar::stop_iteration>(
+ return list_iertr::make_ready_future<seastar::stop_iteration>(
seastar::stop_iteration::yes);
}
auto laddr = biter->get_val();
return omap_load_extent(
oc, laddr,
get_meta().depth - 1
- ).safe_then([&, config, oc] (auto &&extent) {
+ ).si_then([&, config, oc] (auto &&extent) {
return extent->list(
oc,
start,
config.with_reduced_max(result.size())
- ).safe_then([&, config](auto &&child_ret) mutable {
+ ).si_then([&, config](auto &&child_ret) mutable {
auto &[child_complete, child_result] = child_ret;
if (result.size() && child_result.size()) {
assert(child_result.begin()->first > result.rbegin()->first);
result.merge(std::move(child_result));
++biter;
assert(child_complete || result.size() == config.max_result_size);
- return list_ertr::make_ready_future<seastar::stop_iteration>(
+ return list_iertr::make_ready_future<seastar::stop_iteration>(
seastar::stop_iteration::no);
});
});
- }).safe_then([&ret, ref = OMapNodeRef(this)] {
- return list_ertr::make_ready_future<list_bare_ret>(std::move(ret));
+ }).si_then([&ret, ref = OMapNodeRef(this)] {
+ return list_iertr::make_ready_future<list_bare_ret>(std::move(ret));
});
});
}
OMapInnerNode::clear(omap_context_t oc)
{
logger().debug("OMapInnerNode: {}", __func__);
- return crimson::do_for_each(iter_begin(), iter_end(), [this, oc] (auto iter) {
+ return trans_intr::do_for_each(iter_begin(), iter_end(), [this, oc] (auto iter) {
auto laddr = iter->get_val();
- return omap_load_extent(oc, laddr, get_meta().depth - 1).safe_then(
+ return omap_load_extent(oc, laddr, get_meta().depth - 1).si_then(
[oc] (auto &&extent) {
return extent->clear(oc);
- }).safe_then([oc, laddr] {
+ }).si_then([oc, laddr] {
return dec_ref(oc, laddr);
- }).safe_then([ref = OMapNodeRef(this)] {
- return clear_ertr::now();
+ }).si_then([ref = OMapNodeRef(this)] {
+ return clear_iertr::now();
});
});
}
{
logger().debug("OMapInnerNode: {}", __func__);
return oc.tm.alloc_extents<OMapInnerNode>(oc.t, L_ADDR_MIN, OMAP_BLOCK_SIZE, 2)
- .safe_then([this] (auto &&ext_pair) {
+ .si_then([this] (auto &&ext_pair) {
auto left = ext_pair.front();
auto right = ext_pair.back();
return split_children_ret(
- split_children_ertr::ready_future_marker{},
+ interruptible::ready_future_marker{},
std::make_tuple(left, right, split_into(*left, *right)));
});
}
{
logger().debug("OMapInnerNode: {}", __func__);
return oc.tm.alloc_extent<OMapInnerNode>(oc.t, L_ADDR_MIN, OMAP_BLOCK_SIZE)
- .safe_then([this, right] (auto &&replacement) {
+ .si_then([this, right] (auto &&replacement) {
replacement->merge_from(*this, *right->cast<OMapInnerNode>());
return full_merge_ret(
- full_merge_ertr::ready_future_marker{},
+ interruptible::ready_future_marker{},
std::move(replacement));
});
}
logger().debug("OMapInnerNode: {}", __func__);
ceph_assert(_right->get_type() == type);
return oc.tm.alloc_extents<OMapInnerNode>(oc.t, L_ADDR_MIN, OMAP_BLOCK_SIZE, 2)
- .safe_then([this, _right] (auto &&replacement_pair){
+ .si_then([this, _right] (auto &&replacement_pair){
auto replacement_left = replacement_pair.front();
auto replacement_right = replacement_pair.back();
auto &right = *_right->cast<OMapInnerNode>();
return make_balanced_ret(
- make_balanced_ertr::ready_future_marker{},
+ interruptible::ready_future_marker{},
std::make_tuple(replacement_left, replacement_right,
balance_into_new_nodes(*this, right,
*replacement_left, *replacement_right)));
auto is_left = (iter + 1) == iter_end();
auto donor_iter = is_left ? iter - 1 : iter + 1;
return omap_load_extent(oc, donor_iter->get_val(), get_meta().depth - 1)
- .safe_then([=] (auto &&donor) mutable {
+ .si_then([=] (auto &&donor) mutable {
auto [l, r] = is_left ?
std::make_pair(donor, entry) : std::make_pair(entry, donor);
auto [liter, riter] = is_left ?
if (donor->extent_is_below_min()) {
logger().debug("{}::merge_entry make_full_merge l {} r {}", __func__, *l, *r);
assert(entry->extent_is_below_min());
- return l->make_full_merge(oc, r).safe_then([liter=liter, riter=riter,
+ return l->make_full_merge(oc, r).si_then([liter=liter, riter=riter,
l=l, r=r, oc, this] (auto &&replacement){
journal_inner_update(liter, replacement->get_laddr(), maybe_get_delta_buffer());
journal_inner_remove(riter, maybe_get_delta_buffer());
//retire extent
std::vector<laddr_t> dec_laddrs {l->get_laddr(), r->get_laddr()};
- return dec_ref(oc, dec_laddrs).safe_then([this] {
+ return dec_ref(oc, dec_laddrs).si_then([this] {
if (extent_is_below_min()) {
return merge_entry_ret(
- merge_entry_ertr::ready_future_marker{},
+ interruptible::ready_future_marker{},
mutation_result_t(mutation_status_t::NEED_MERGE, std::nullopt,
this));
} else {
return merge_entry_ret(
- merge_entry_ertr::ready_future_marker{},
+ interruptible::ready_future_marker{},
mutation_result_t(mutation_status_t::SUCCESS, std::nullopt, std::nullopt));
}
});
});
} else {
logger().debug("{}::merge_entry balanced l {} r {}", __func__, *l, *r);
- return l->make_balanced(oc, r).safe_then([liter=liter, riter=riter,
+ return l->make_balanced(oc, r).si_then([liter=liter, riter=riter,
l=l, r=r, oc, this] (auto tuple) {
auto [replacement_l, replacement_r, replacement_pivot] = tuple;
//update operation will not cuase node overflow, so we can do it first
replacement_pivot,
maybe_get_delta_buffer());
std::vector<laddr_t> dec_laddrs{l->get_laddr(), r->get_laddr()};
- return dec_ref(oc, dec_laddrs).safe_then([] {
+ return dec_ref(oc, dec_laddrs).si_then([] {
return merge_entry_ret(
- merge_entry_ertr::ready_future_marker{},
+ interruptible::ready_future_marker{},
mutation_result_t(mutation_status_t::SUCCESS, std::nullopt, std::nullopt));
});
} else {
//remove operation will not cause node split, so we can do it first
journal_inner_remove(riter, maybe_get_delta_buffer());
return make_split_insert(oc, riter, replacement_pivot, replacement_r->get_laddr())
- .safe_then([this, oc, l = l, r = r] (auto mresult) {
+ .si_then([this, oc, l = l, r = r] (auto mresult) {
std::vector<laddr_t> dec_laddrs{l->get_laddr(), r->get_laddr(), get_laddr()};
return dec_ref(oc, dec_laddrs)
- .safe_then([mresult = std::move(mresult)] {
+ .si_then([mresult = std::move(mresult)] {
return merge_entry_ret(
- merge_entry_ertr::ready_future_marker{},
+ interruptible::ready_future_marker{},
mresult);
});
});
if (ite != iter_end()) {
auto value = ite->get_val();
return get_value_ret(
- get_value_ertr::ready_future_marker{},
+ interruptible::ready_future_marker{},
value);
} else {
return get_value_ret(
- get_value_ertr::ready_future_marker{},
+ interruptible::ready_future_marker{},
std::nullopt);
}
}
insert_pt.get_key());
}
return insert_ret(
- insert_ertr::ready_future_marker{},
+ interruptible::ready_future_marker{},
mutation_result_t(mutation_status_t::SUCCESS, std::nullopt, std::nullopt));
} else {
- return make_split_children(oc).safe_then([this, oc, &key, &value] (auto tuple) {
+ return make_split_children(oc).si_then([this, oc, &key, &value] (auto tuple) {
auto [left, right, pivot] = tuple;
auto replace_pt = find_string_key(key);
if (replace_pt != iter_end()) {
}
}
return dec_ref(oc, get_laddr())
- .safe_then([tuple = std::move(tuple)] {
+ .si_then([tuple = std::move(tuple)] {
return insert_ret(
- insert_ertr::ready_future_marker{},
+ interruptible::ready_future_marker{},
mutation_result_t(mutation_status_t::WAS_SPLIT, tuple, std::nullopt));
});
});
journal_leaf_remove(rm_pt, maybe_get_delta_buffer());
if (extent_is_below_min()) {
return rm_key_ret(
- rm_key_ertr::ready_future_marker{},
+ interruptible::ready_future_marker{},
mutation_result_t(mutation_status_t::NEED_MERGE, std::nullopt,
this->cast<OMapNode>()));
} else {
return rm_key_ret(
- rm_key_ertr::ready_future_marker{},
+ interruptible::ready_future_marker{},
mutation_result_t(mutation_status_t::SUCCESS, std::nullopt, std::nullopt));
}
} else {
return rm_key_ret(
- rm_key_ertr::ready_future_marker{},
+ interruptible::ready_future_marker{},
mutation_result_t(mutation_status_t::FAIL, std::nullopt, std::nullopt));
}
complete = (iter == iter_end());
- return list_ertr::make_ready_future<list_bare_ret>(
+ return list_iertr::make_ready_future<list_bare_ret>(
std::move(ret));
}
OMapLeafNode::clear_ret
OMapLeafNode::clear(omap_context_t oc)
{
- return clear_ertr::now();
+ return clear_iertr::now();
}
OMapLeafNode::split_children_ret
{
logger().debug("OMapLeafNode: {}", __func__);
return oc.tm.alloc_extents<OMapLeafNode>(oc.t, L_ADDR_MIN, OMAP_BLOCK_SIZE, 2)
- .safe_then([this] (auto &&ext_pair) {
+ .si_then([this] (auto &&ext_pair) {
auto left = ext_pair.front();
auto right = ext_pair.back();
return split_children_ret(
- split_children_ertr::ready_future_marker{},
+ interruptible::ready_future_marker{},
std::make_tuple(left, right, split_into(*left, *right)));
});
}
ceph_assert(right->get_type() == type);
logger().debug("OMapLeafNode: {}", __func__);
return oc.tm.alloc_extent<OMapLeafNode>(oc.t, L_ADDR_MIN, OMAP_BLOCK_SIZE)
- .safe_then([this, right] (auto &&replacement) {
+ .si_then([this, right] (auto &&replacement) {
replacement->merge_from(*this, *right->cast<OMapLeafNode>());
return full_merge_ret(
- full_merge_ertr::ready_future_marker{},
+ interruptible::ready_future_marker{},
std::move(replacement));
});
}
ceph_assert(_right->get_type() == type);
logger().debug("OMapLeafNode: {}", __func__);
return oc.tm.alloc_extents<OMapLeafNode>(oc.t, L_ADDR_MIN, OMAP_BLOCK_SIZE, 2)
- .safe_then([this, _right] (auto &&replacement_pair) {
+ .si_then([this, _right] (auto &&replacement_pair) {
auto replacement_left = replacement_pair.front();
auto replacement_right = replacement_pair.back();
auto &right = *_right->cast<OMapLeafNode>();
return make_balanced_ret(
- make_balanced_ertr::ready_future_marker{},
+ interruptible::ready_future_marker{},
std::make_tuple(
replacement_left, replacement_right,
balance_into_new_nodes(
}
-omap_load_extent_ertr::future<OMapNodeRef>
+omap_load_extent_iertr::future<OMapNodeRef>
omap_load_extent(omap_context_t oc, laddr_t laddr, depth_t depth)
{
ceph_assert(depth > 0);
if (depth > 1) {
return oc.tm.read_extent<OMapInnerNode>(oc.t, laddr, OMAP_BLOCK_SIZE
- ).handle_error(
- omap_load_extent_ertr::pass_further{},
+ ).handle_error_interruptible(
+ omap_load_extent_iertr::pass_further{},
crimson::ct_error::assert_all{ "Invalid error in omap_load_extent" }
- ).safe_then(
+ ).si_then(
[](auto&& e) {
return seastar::make_ready_future<OMapNodeRef>(std::move(e));
});
} else {
return oc.tm.read_extent<OMapLeafNode>(oc.t, laddr, OMAP_BLOCK_SIZE
- ).handle_error(
- omap_load_extent_ertr::pass_further{},
+ ).handle_error_interruptible(
+ omap_load_extent_iertr::pass_further{},
crimson::ct_error::assert_all{ "Invalid error in omap_load_extent" }
- ).safe_then(
+ ).si_then(
[](auto&& e) {
return seastar::make_ready_future<OMapNodeRef>(std::move(e));
});
clear_ret clear(omap_context_t oc) final;
- using split_children_ertr = base_ertr;
- using split_children_ret = split_children_ertr::future
+ using split_children_iertr = base_iertr;
+ using split_children_ret = split_children_iertr::future
<std::tuple<OMapInnerNodeRef, OMapInnerNodeRef, std::string>>;
split_children_ret make_split_children(omap_context_t oc);
make_balanced_ret make_balanced(
omap_context_t oc, OMapNodeRef right) final;
- using make_split_insert_ertr = base_ertr;
- using make_split_insert_ret = make_split_insert_ertr::future<mutation_result_t>;
+ using make_split_insert_iertr = base_iertr;
+ using make_split_insert_ret = make_split_insert_iertr::future<mutation_result_t>;
make_split_insert_ret make_split_insert(
omap_context_t oc, internal_iterator_t iter,
std::string key, laddr_t laddr);
- using merge_entry_ertr = base_ertr;
- using merge_entry_ret = merge_entry_ertr::future<mutation_result_t>;
+ using merge_entry_iertr = base_iertr;
+ using merge_entry_ret = merge_entry_iertr::future<mutation_result_t>;
merge_entry_ret merge_entry(
omap_context_t oc,
internal_iterator_t iter, OMapNodeRef entry);
- using handle_split_ertr = base_ertr;
- using handle_split_ret = handle_split_ertr::future<mutation_result_t>;
+ using handle_split_iertr = base_iertr;
+ using handle_split_ret = handle_split_iertr::future<mutation_result_t>;
handle_split_ret handle_split(
omap_context_t oc, internal_iterator_t iter,
mutation_result_t mresult);
clear_ret clear(
omap_context_t oc) final;
- using split_children_ertr = base_ertr;
- using split_children_ret = split_children_ertr::future
+ using split_children_iertr = base_iertr;
+ using split_children_ret = split_children_iertr::future
<std::tuple<OMapLeafNodeRef, OMapLeafNodeRef, std::string>>;
split_children_ret make_split_children(
omap_context_t oc);
return iter_t<!is_const>(node, index);
}
+ using reference = iter_t&;
iter_t &operator*() { return *this; }
iter_t *operator->() { return this; }
std::string_view key) const
{
return seastar::do_with(
- BtreeOMapManager(*transaction_manager),
+ BtreeOMapManager(transaction_manager->get_tm()),
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 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<ceph::bufferlist>(std::move(*opt));
- });
+ 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<ceph::bufferlist>(std::move(*opt));
+ });
});
}
return seastar::make_ready_future<omap_values_t>();
}
return seastar::do_with(
- BtreeOMapManager(*transaction_manager),
+ BtreeOMapManager(transaction_manager->get_tm()),
std::move(omap_root),
omap_values_t(),
[&](auto &manager, auto &root, auto &ret) {
- return crimson::do_for_each(
- keys.begin(),
- keys.end(),
- [&](auto &key) {
- return manager.omap_get_value(
- root,
- t,
- key
- ).safe_then([&ret, &key](auto &&p) {
- if (p) {
- bufferlist bl;
- bl.append(*p);
- ret.emplace(
- std::make_pair(
- std::move(key),
- std::move(bl)));
- }
- return seastar::now();
- });
- }).safe_then([&ret] {
- return std::move(ret);
+ return with_trans_intr(
+ t,
+ [&, this](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::make_pair(
+ std::move(key),
+ std::move(bl)));
+ }
+ return seastar::now();
+ });
+ }).si_then([&ret] {
+ return std::move(ret);
+ });
});
});
}
);
}
return seastar::do_with(
- BtreeOMapManager(*transaction_manager),
+ BtreeOMapManager(transaction_manager->get_tm()),
root,
start,
[&t, config](auto &manager, auto& root, auto& start) {
- return manager.omap_list(root, t, start, config);
- });
+ return with_trans_intr(
+ t,
+ [&](auto &t) {
+ return manager.omap_list(root, t, start, config);
+ });
+ });
}
SeaStore::omap_get_values_ret_t SeaStore::omap_list(
std::map<std::string, ceph::bufferlist>&& kvs)
{
return seastar::do_with(
- BtreeOMapManager(*transaction_manager),
+ BtreeOMapManager(transaction_manager->get_tm()),
omap_root.get(),
- [&t, keys=std::move(kvs)](auto &omap_manager, auto &root) {
- tm_ertr::future<> maybe_create_root =
- !root.is_null() ?
- tm_ertr::now() :
- omap_manager.initialize_omap(t)
- .safe_then([&root](auto new_root) {
- root = new_root;
- });
-
- return maybe_create_root.safe_then(
- [&, keys=std::move(keys)]() mutable {
- return omap_manager.omap_set_keys(root, t, std::move(keys));
- }).safe_then([&] {
- return tm_ertr::make_ready_future<omap_root_t>(std::move(root));
+ [&, 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<omap_root_t>(std::move(root));
+ }).si_then([&mutable_omap_root](auto root) {
+ if (root.must_update()) {
+ mutable_omap_root.update(root);
+ }
+ });
+ });
});
- }).safe_then([&mutable_omap_root](auto root) {
- if (root.must_update()) {
- mutable_omap_root.update(root);
- }
- });
}
SeaStore::tm_ret SeaStore::_omap_set_values(
return seastar::now();
} else {
return seastar::do_with(
- BtreeOMapManager(*transaction_manager),
+ BtreeOMapManager(transaction_manager->get_tm()),
onode->get_layout().omap_root.get(),
std::move(keys),
[&ctx, &onode](
auto &omap_manager,
auto &omap_root,
auto &keys) {
- return crimson::do_for_each(
- keys.begin(),
- keys.end(),
- [&](auto &p) {
- return omap_manager.omap_rm_key(
- omap_root,
- *ctx.transaction,
- p);
- }).safe_then([&] {
- if (omap_root.must_update()) {
- onode->get_mutable_layout(*ctx.transaction
- ).omap_root.update(omap_root);
- }
+ 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);
+ }
+ });
});
});
}
});
}
- using _omap_get_value_ertr = OMapManager::base_ertr::extend<
+ using _omap_get_value_ertr = with_trans_ertr<OMapManager::base_iertr>::extend<
crimson::ct_error::enodata
>;
using _omap_get_value_ret = _omap_get_value_ertr::future<ceph::bufferlist>;
omap_root_t &&root,
std::string_view key) const;
- using _omap_get_values_ertr = OMapManager::base_ertr;
+ using _omap_get_values_ertr = with_trans_ertr<OMapManager::base_iertr>;
using _omap_get_values_ret = _omap_get_values_ertr::future<omap_values_t>;
_omap_get_values_ret _omap_get_values(
Transaction &t,
const omap_keys_t &keys) const;
using _omap_list_bare_ret = OMapManager::omap_list_bare_ret;
- using _omap_list_ret = OMapManager::omap_list_ret;
+ using _omap_list_ret =
+ _omap_get_values_ertr::future<OMapManager::omap_list_bare_ret>;
_omap_list_ret _omap_list(
const omap_root_le_t& omap_root,
Transaction& t,
CollectionManagerRef collection_manager;
OnodeManagerRef onode_manager;
- using tm_ertr = with_trans_ertr<TransactionManager::base_iertr>;
+ using tm_iertr = TransactionManager::base_iertr;
+ using tm_ertr = with_trans_ertr<tm_iertr>;
using tm_ret = tm_ertr::future<>;
tm_ret _do_transaction_step(
internal_context_t &ctx,
InterruptedTransactionManager &operator=(
InterruptedTransactionManager &&) = default;
+ TransactionManager &get_tm() const { return *tm; }
+
FORWARD(mkfs)
FORWARD(mount)
FORWARD(close)
seastar::future<> set_up_fut() final {
return tm_setup().then([this] {
- omap_manager = omap_manager::create_omap_manager(itm);
+ omap_manager = omap_manager::create_omap_manager(*tm);
return seastar::now();
});
}
Transaction &t,
const string &key,
const bufferlist &val) {
- omap_manager->omap_set_key(omap_root, t, key, val).unsafe_get0();
+ with_trans_intr(
+ t,
+ [&, this](auto &t) {
+ return omap_manager->omap_set_key(omap_root, t, key, val);
+ }).unsafe_get0();
test_omap_mappings[key] = val;
}
omap_root_t &omap_root,
Transaction &t,
const string &key) {
- auto ret = omap_manager->omap_get_value(omap_root, t, key).unsafe_get0();
+ auto ret = with_trans_intr(
+ t,
+ [&, this](auto &t) {
+ return omap_manager->omap_get_value(omap_root, t, key);
+ }).unsafe_get0();
auto iter = test_omap_mappings.find(key);
if (iter == test_omap_mappings.end()) {
EXPECT_FALSE(ret);
omap_root_t &omap_root,
Transaction &t,
const string &key) {
- omap_manager->omap_rm_key(omap_root, t, key).unsafe_get0();
+ with_trans_intr(
+ t,
+ [&, this](auto &t) {
+ return omap_manager->omap_rm_key(omap_root, t, key);
+ }).unsafe_get0();
test_omap_mappings.erase(test_omap_mappings.find(key));
}
auto config = OMapManager::omap_list_config_t::with_max(max);
config.max_result_size = max;
- auto [complete, results] = omap_manager->omap_list(
- omap_root, t, start, config
- ).unsafe_get0();
+
+ auto [complete, results] = with_trans_intr(
+ t,
+ [&, this](auto &t) {
+ return omap_manager->omap_list(omap_root, t, start, config);
+ }).unsafe_get0();
auto it = start ?
test_omap_mappings.upper_bound(*start) :
void clear(
omap_root_t &omap_root,
Transaction &t) {
- omap_manager->omap_clear(omap_root, t).unsafe_get0();
+ with_trans_intr(
+ t,
+ [&, this](auto &t) {
+ return omap_manager->omap_clear(omap_root, t);
+ }).unsafe_get0();
EXPECT_EQ(omap_root.get_location(), L_ADDR_NULL);
}
}
return mkeys;
}
+
void replay() {
logger().debug("{}: begin", __func__);
restart();
- omap_manager = omap_manager::create_omap_manager(itm);
+ omap_manager = omap_manager::create_omap_manager(*tm);
logger().debug("{}: end", __func__);
}
+
+ auto initialize() {
+ auto t = tm->create_transaction();
+ omap_root_t omap_root = with_trans_intr(
+ *t,
+ [this](auto &t) {
+ return omap_manager->initialize_omap(t);
+ }).unsafe_get0();
+ submit_transaction(std::move(t));
+ return omap_root;
+ }
};
TEST_F(omap_manager_test_t, basic)
{
run_async([this] {
- omap_root_t omap_root(L_ADDR_NULL, 0);
- {
- auto t = tm->create_transaction();
- omap_root = omap_manager->initialize_omap(*t).unsafe_get0();
- submit_transaction(std::move(t));
- }
+ omap_root_t omap_root = initialize();
string key = "owner";
string val = "test";
TEST_F(omap_manager_test_t, force_leafnode_split)
{
run_async([this] {
- omap_root_t omap_root(L_ADDR_NULL, 0);
- {
- auto t = tm->create_transaction();
- omap_root = omap_manager->initialize_omap(*t).unsafe_get0();
- submit_transaction(std::move(t));
- }
+ omap_root_t omap_root = initialize();
+
for (unsigned i = 0; i < 40; i++) {
auto t = tm->create_transaction();
logger().debug("opened transaction");
TEST_F(omap_manager_test_t, force_leafnode_split_merge)
{
run_async([this] {
- omap_root_t omap_root(L_ADDR_NULL, 0);
- {
- auto t = tm->create_transaction();
- omap_root = omap_manager->initialize_omap(*t).unsafe_get0();
- submit_transaction(std::move(t));
- }
+ omap_root_t omap_root = initialize();
for (unsigned i = 0; i < 80; i++) {
auto t = tm->create_transaction();
TEST_F(omap_manager_test_t, force_leafnode_split_merge_fullandbalanced)
{
run_async([this] {
- omap_root_t omap_root(L_ADDR_NULL, 0);
- {
- auto t = tm->create_transaction();
- omap_root = omap_manager->initialize_omap(*t).unsafe_get0();
- submit_transaction(std::move(t));
- }
+ omap_root_t omap_root = initialize();
for (unsigned i = 0; i < 50; i++) {
auto t = tm->create_transaction();
TEST_F(omap_manager_test_t, force_split_listkeys_list_clear)
{
run_async([this] {
- omap_root_t omap_root(L_ADDR_NULL, 0);
- {
- auto t = tm->create_transaction();
- omap_root = omap_manager->initialize_omap(*t).unsafe_get0();
- submit_transaction(std::move(t));
- }
+ omap_root_t omap_root = initialize();
+
string temp;
for (unsigned i = 0; i < 40; i++) {
auto t = tm->create_transaction();
TEST_F(omap_manager_test_t, internal_force_split)
{
run_async([this] {
- omap_root_t omap_root(L_ADDR_NULL, 0);
- {
- auto t = tm->create_transaction();
- omap_root = omap_manager->initialize_omap(*t).unsafe_get0();
- submit_transaction(std::move(t));
- }
+ omap_root_t omap_root = initialize();
+
for (unsigned i = 0; i < 10; i++) {
logger().debug("opened split transaction");
auto t = tm->create_transaction();
TEST_F(omap_manager_test_t, internal_force_merge_fullandbalanced)
{
run_async([this] {
- omap_root_t omap_root(L_ADDR_NULL, 0);
- {
- auto t = tm->create_transaction();
- omap_root = omap_manager->initialize_omap(*t).unsafe_get0();
- submit_transaction(std::move(t));
- }
+ omap_root_t omap_root = initialize();
for (unsigned i = 0; i < 8; i++) {
logger().debug("opened split transaction");
TEST_F(omap_manager_test_t, replay)
{
run_async([this] {
- omap_root_t omap_root(L_ADDR_NULL, 0);
- {
- auto t = tm->create_transaction();
- omap_root = omap_manager->initialize_omap(*t).unsafe_get0();
- submit_transaction(std::move(t));
- replay();
- }
+ omap_root_t omap_root = initialize();
for (unsigned i = 0; i < 8; i++) {
logger().debug("opened split transaction");
TEST_F(omap_manager_test_t, internal_force_split_to_root)
{
run_async([this] {
- omap_root_t omap_root(L_ADDR_NULL, 0);
- {
- auto t = tm->create_transaction();
- omap_root = omap_manager->initialize_omap(*t).unsafe_get0();
- submit_transaction(std::move(t));
- }
+ omap_root_t omap_root = initialize();
logger().debug("set big keys");
for (unsigned i = 0; i < 53; i++) {
projects / ceph.git / commitdiff