namespace crimson::os::seastore {
+#define LBA_INT_FORWARD(METHOD) \
+ template <typename... Args> \
+ auto METHOD(Transaction &t, Args&&... args) { \
+ return with_trans_intr( \
+ t, \
+ [this](auto&&... args) { \
+ return this->_##METHOD(args...); \
+ }, \
+ std::forward<Args>(args)...); \
+ }
+
/**
* Abstract interface for managing the logical to physical mapping
*/
class LBAManager {
public:
- using base_ertr = Cache::get_extent_ertr;
+ using base_ertr = Cache::base_ertr;
+ using base_iertr = Cache::base_iertr;
using mkfs_ertr = crimson::errorator<
crimson::ct_error::input_output_error>;
* Future will not resolve until all pins have resolved (set_paddr called)
*/
using get_mappings_ertr = base_ertr;
- using get_mappings_ret = get_mappings_ertr::future<lba_pin_list_t>;
- virtual get_mappings_ret get_mappings(
+ using get_mappings_iertr = trans_iertr<base_ertr>;
+ using get_mappings_ret = get_mappings_iertr::future<lba_pin_list_t>;
+ virtual get_mappings_ret _get_mappings(
Transaction &t,
laddr_t offset, extent_len_t length) = 0;
*
* Future will not resolve until all pins have resolved (set_paddr called)
*/
- virtual get_mappings_ret get_mappings(
+ virtual get_mappings_ret _get_mappings(
Transaction &t,
laddr_list_t &&extent_lisk) = 0;
+ LBA_INT_FORWARD(get_mappings)
/**
* Fetches the mapping for laddr_t
*/
using get_mapping_ertr = base_ertr::extend<
crimson::ct_error::enoent>;
- using get_mapping_ret = get_mapping_ertr::future<LBAPinRef>;
- virtual get_mapping_ret get_mapping(
+ using get_mapping_iertr = base_iertr::extend<
+ crimson::ct_error::enoent>;
+ using get_mapping_ret = get_mapping_iertr::future<LBAPinRef>;
+ virtual get_mapping_ret _get_mapping(
Transaction &t,
laddr_t offset) = 0;
+ LBA_INT_FORWARD(get_mapping)
/**
* Finds unmapped laddr extent of len len
*/
using find_hole_ertr = base_ertr;
- using find_hole_ret = find_hole_ertr::future<
+ using find_hole_iertr = base_iertr;
+ using find_hole_ret = find_hole_iertr::future<
std::pair<laddr_t, extent_len_t>
>;
- virtual find_hole_ret find_hole(
+ virtual find_hole_ret _find_hole(
Transaction &t,
laddr_t hint,
extent_len_t) = 0;
+ LBA_INT_FORWARD(find_hole)
/**
* Allocates a new mapping referenced by LBARef
* is called on the LBAPin.
*/
using alloc_extent_ertr = base_ertr;
- using alloc_extent_ret = alloc_extent_ertr::future<LBAPinRef>;
- virtual alloc_extent_ret alloc_extent(
+ using alloc_extent_iertr = base_iertr;
+ using alloc_extent_ret = alloc_extent_iertr::future<LBAPinRef>;
+ virtual alloc_extent_ret _alloc_extent(
Transaction &t,
laddr_t hint,
extent_len_t len,
paddr_t addr) = 0;
+ LBA_INT_FORWARD(alloc_extent)
/**
* Creates a new absolute mapping.
*
* off~len must be unreferenced
*/
- using set_extent_ertr = base_ertr::extend<
+ using set_extent_iertr = base_iertr::extend<
crimson::ct_error::invarg>;
- using set_extent_ret = set_extent_ertr::future<LBAPinRef>;
- virtual set_extent_ret set_extent(
+ using set_extent_ret = set_extent_iertr::future<LBAPinRef>;
+ virtual set_extent_ret _set_extent(
Transaction &t,
laddr_t off, extent_len_t len, paddr_t addr) = 0;
+ LBA_INT_FORWARD(set_extent)
struct ref_update_result_t {
};
using ref_ertr = base_ertr::extend<
crimson::ct_error::enoent>;
- using ref_ret = ref_ertr::future<ref_update_result_t>;
+ using ref_iertr = base_iertr::extend<
+ crimson::ct_error::enoent>;
+ using ref_ret = ref_iertr::future<ref_update_result_t>;
/**
* Decrements ref count on extent
*
* @return returns resulting refcount
*/
- virtual ref_ret decref_extent(
+ virtual ref_ret _decref_extent(
Transaction &t,
laddr_t addr) = 0;
+ LBA_INT_FORWARD(decref_extent)
/**
* Increments ref count on extent
*
* @return returns resulting refcount
*/
- virtual ref_ret incref_extent(
+ virtual ref_ret _incref_extent(
Transaction &t,
laddr_t addr) = 0;
+ LBA_INT_FORWARD(incref_extent)
virtual void complete_transaction(
Transaction &t) = 0;
* LogicalCachedExtent's and may also read in any dependent
* structures, etc.
*/
- using init_cached_extent_ertr = base_ertr;
- using init_cached_extent_ret = init_cached_extent_ertr::future<>;
- virtual init_cached_extent_ret init_cached_extent(
+ using init_cached_extent_iertr = base_iertr;
+ using init_cached_extent_ret = init_cached_extent_iertr::future<>;
+ virtual init_cached_extent_ret _init_cached_extent(
Transaction &t,
CachedExtentRef e) = 0;
+ LBA_INT_FORWARD(init_cached_extent)
/**
* Calls f for each mapping in [begin, end)
*/
- using scan_mappings_ertr = base_ertr;
- using scan_mappings_ret = scan_mappings_ertr::future<>;
+ using scan_mappings_iertr = base_iertr;
+ using scan_mappings_ret = scan_mappings_iertr::future<>;
using scan_mappings_func_t = std::function<
void(laddr_t, paddr_t, extent_len_t)>;
- virtual scan_mappings_ret scan_mappings(
+ virtual scan_mappings_ret _scan_mappings(
Transaction &t,
laddr_t begin,
laddr_t end,
scan_mappings_func_t &&f) = 0;
+ LBA_INT_FORWARD(scan_mappings)
/**
* Calls f for each mapped space usage in [begin, end)
*/
- using scan_mapped_space_ertr = base_ertr::extend_ertr<
+ using scan_mapped_space_iertr = base_iertr::extend_ertr<
SegmentManager::read_ertr>;
- using scan_mapped_space_ret = scan_mapped_space_ertr::future<>;
+ using scan_mapped_space_ret = scan_mapped_space_iertr::future<>;
using scan_mapped_space_func_t = std::function<
void(paddr_t, extent_len_t)>;
- virtual scan_mapped_space_ret scan_mapped_space(
+ virtual scan_mapped_space_ret _scan_mapped_space(
Transaction &t,
scan_mapped_space_func_t &&f) = 0;
+ LBA_INT_FORWARD(scan_mapped_space)
/**
* rewrite_extent
*
* rewrite extent into passed transaction
*/
- using rewrite_extent_ertr = base_ertr;
- using rewrite_extent_ret = rewrite_extent_ertr::future<>;
- virtual rewrite_extent_ret rewrite_extent(
+ using rewrite_extent_iertr = base_iertr;
+ using rewrite_extent_ret = rewrite_extent_iertr::future<>;
+ virtual rewrite_extent_ret _rewrite_extent(
Transaction &t,
CachedExtentRef extent) = 0;
+ LBA_INT_FORWARD(rewrite_extent)
/**
* get_physical_extent_if_live
*
* Returns a null CachedExtentRef if extent is not live.
*/
- using get_physical_extent_if_live_ertr = base_ertr;
+ using get_physical_extent_if_live_iertr = base_iertr;
using get_physical_extent_if_live_ret =
- get_physical_extent_if_live_ertr::future<CachedExtentRef>;
- virtual get_physical_extent_if_live_ret get_physical_extent_if_live(
+ get_physical_extent_if_live_iertr::future<CachedExtentRef>;
+ virtual get_physical_extent_if_live_ret _get_physical_extent_if_live(
Transaction &t,
extent_types_t type,
paddr_t addr,
laddr_t laddr,
segment_off_t len) = 0;
+ LBA_INT_FORWARD(get_physical_extent_if_live)
virtual void add_pin(LBAPin &pin) = 0;
Transaction &t)
{
logger().debug("BtreeLBAManager::mkfs");
- return cache.get_root(t).safe_then([this, &t](auto croot) {
- auto root_leaf = cache.alloc_new_extent<LBALeafNode>(
- 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 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<LBALeafNode>(
+ 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"
+ }
+ );
}
BtreeLBAManager::get_root_ret
BtreeLBAManager::get_root(Transaction &t)
{
- return cache.get_root(t).safe_then([this, &t](auto croot) {
+ return cache.get_root(t).si_then([this, &t](auto croot) {
logger().debug(
"BtreeLBAManager::get_root: reading root at {} depth {}",
paddr_t{croot->get_root().lba_root.get_location()},
}
BtreeLBAManager::get_mappings_ret
-BtreeLBAManager::get_mappings(
+BtreeLBAManager::_get_mappings(
Transaction &t,
laddr_t offset, extent_len_t length)
{
logger().debug("BtreeLBAManager::get_mappings: {}, {}", offset, length);
return get_root(
- t).safe_then([this, &t, offset, length](auto extent) {
+ t).si_then([this, &t, offset, length](auto extent) {
return extent->lookup_range(
get_context(t),
offset, length
- ).safe_then([](auto &&e) {
+ ).si_then([](auto &&e) {
logger().debug("BtreeLBAManager::get_mappings: got mappings {}", e);
- return get_mappings_ret(
- get_mappings_ertr::ready_future_marker{},
- std::move(e));
+ return std::move(e);
});
});
}
BtreeLBAManager::get_mappings_ret
-BtreeLBAManager::get_mappings(
+BtreeLBAManager::_get_mappings(
Transaction &t,
laddr_list_t &&list)
{
auto l = std::make_unique<laddr_list_t>(std::move(list));
auto retptr = std::make_unique<lba_pin_list_t>();
auto &ret = *retptr;
- return crimson::do_for_each(
+ return trans_intr::do_for_each(
l->begin(),
l->end(),
[this, &t, &ret](const auto &p) {
- return get_mappings(t, p.first, p.second).safe_then(
+ return _get_mappings(t, p.first, p.second).si_then(
[&ret](auto res) {
ret.splice(ret.end(), res, res.begin(), res.end());
+ return get_mappings_iertr::now();
});
- }).safe_then([l=std::move(l), retptr=std::move(retptr)]() mutable {
+ }).si_then([l=std::move(l), retptr=std::move(retptr)]() mutable {
return std::move(*retptr);
});
}
BtreeLBAManager::get_mapping_ret
-BtreeLBAManager::get_mapping(
+BtreeLBAManager::_get_mapping(
Transaction &t,
laddr_t offset)
{
logger().debug("BtreeLBAManager::get_mapping: {}", offset);
return get_root(t
- ).safe_then([this, &t, offset] (auto extent) {
+ ).si_then([this, &t, offset] (auto extent) {
return extent->lookup_pin(get_context(t), offset);
- }).safe_then([] (auto &&e) {
+ }).si_then([] (auto &&e) {
logger().debug("BtreeLBAManager::get_mapping: got mapping {}", *e);
- return get_mapping_ret(
- get_mapping_ertr::ready_future_marker{},
- std::move(e));
+ return std::move(e);
});
}
BtreeLBAManager::find_hole_ret
-BtreeLBAManager::find_hole(
+BtreeLBAManager::_find_hole(
Transaction &t,
laddr_t hint,
extent_len_t len)
{
return get_root(t
- ).safe_then([this, hint, len, &t](auto extent) {
+ ).si_then([this, hint, len, &t](auto extent) {
return extent->find_hole(
get_context(t),
hint,
L_ADDR_MAX,
len);
- }).safe_then([len](auto addr) {
- return seastar::make_ready_future<std::pair<laddr_t, extent_len_t>>(
- addr, len);
+ }).si_then([len](auto addr) {
+ return std::make_pair(addr, len);
});
-
}
BtreeLBAManager::alloc_extent_ret
-BtreeLBAManager::alloc_extent(
+BtreeLBAManager::_alloc_extent(
Transaction &t,
laddr_t hint,
extent_len_t len,
{
// TODO: we can certainly combine the lookup and the insert.
return get_root(
- t).safe_then([this, &t, hint, len](auto extent) {
+ t).si_then([this, &t, hint, len](auto extent) {
logger().debug(
"BtreeLBAManager::alloc_extent: beginning search at {}",
*extent);
get_context(t),
hint,
L_ADDR_MAX,
- len).safe_then([extent](auto ret) {
+ len).si_then([extent](auto ret) {
return std::make_pair(ret, extent);
});
- }).safe_then([this, &t, len, addr](auto allocation_pair) {
+ }).si_then([this, &t, len, addr](auto allocation_pair) {
auto &[laddr, extent] = allocation_pair;
ceph_assert(laddr != L_ADDR_MAX);
return insert_mapping(
extent,
laddr,
{ len, addr, 1, 0 }
- ).safe_then([laddr=laddr, addr, len](auto pin) {
+ ).si_then([laddr=laddr, addr, len](auto pin) {
logger().debug(
"BtreeLBAManager::alloc_extent: alloc {}~{} for {}",
laddr,
len,
addr);
- return alloc_extent_ret(
- alloc_extent_ertr::ready_future_marker{},
- LBAPinRef(pin.release()));
+ return LBAPinRef(pin.release());
});
});
}
BtreeLBAManager::set_extent_ret
-BtreeLBAManager::set_extent(
+BtreeLBAManager::_set_extent(
Transaction &t,
laddr_t off, extent_len_t len, paddr_t addr)
{
return get_root(
- t).safe_then([this, &t, off, len, addr](auto root) {
+ t).si_then([this, &t, off, len, addr](auto root) {
return insert_mapping(
t,
root,
off,
{ len, addr, 1, 0 });
- }).safe_then([](auto ret) {
+ }).si_then([](auto ret) {
return set_extent_ret(
- set_extent_ertr::ready_future_marker{},
+ interruptible::ready_future_marker{},
LBAPinRef(ret.release()));
});
}
}
}
-BtreeLBAManager::init_cached_extent_ret BtreeLBAManager::init_cached_extent(
+BtreeLBAManager::init_cached_extent_ret BtreeLBAManager::_init_cached_extent(
Transaction &t,
CachedExtentRef e)
{
logger().debug("{}: {}", __func__, *e);
- return get_root(t).safe_then(
+ return get_root(t).si_then(
[this, &t, e=std::move(e)](LBANodeRef root) mutable {
if (is_lba_node(*e)) {
auto lban = e->cast<LBANode>();
op_context_t{cache, pin_set, t},
lban->get_node_meta().begin,
lban->get_node_meta().depth
- ).safe_then([this, e=std::move(e)](LBANodeRef c) {
+ ).si_then([this, e=std::move(e)](LBANodeRef c) {
if (c->get_paddr() == e->get_paddr()) {
assert(&*c == &*e);
logger().debug("init_cached_extent: {} initialized", *e);
logger().debug("init_cached_extent: {} obsolete", *e);
cache.drop_from_cache(e);
}
- return init_cached_extent_ertr::now();
+ return init_cached_extent_iertr::now();
});
} else if (e->is_logical()) {
auto logn = e->cast<LogicalCachedExtent>();
return root->lookup_range(
op_context_t{cache, pin_set, t},
logn->get_laddr(),
- logn->get_length()).safe_then(
+ logn->get_length()).si_then(
[this, logn=std::move(logn)](auto pins) {
if (pins.size() == 1) {
auto pin = std::move(pins.front());
logger().debug("init_cached_extent: {} obsolete", *logn);
cache.drop_from_cache(logn);
}
- return init_cached_extent_ertr::now();
+ return init_cached_extent_iertr::now();
});
} else {
logger().debug("init_cached_extent: {} skipped", *e);
- return init_cached_extent_ertr::now();
+ return init_cached_extent_iertr::now();
}
});
}
-BtreeLBAManager::scan_mappings_ret BtreeLBAManager::scan_mappings(
+BtreeLBAManager::scan_mappings_ret BtreeLBAManager::_scan_mappings(
Transaction &t,
laddr_t begin,
laddr_t end,
std::move(f),
LBANodeRef(),
[=, &t](auto &f, auto &lbarootref) {
- return get_root(t).safe_then(
+ return get_root(t).si_then(
[=, &t, &f](LBANodeRef lbaroot) mutable {
lbarootref = lbaroot;
return lbaroot->scan_mappings(
});
}
-BtreeLBAManager::scan_mapped_space_ret BtreeLBAManager::scan_mapped_space(
+BtreeLBAManager::scan_mapped_space_ret BtreeLBAManager::_scan_mapped_space(
Transaction &t,
scan_mapped_space_func_t &&f)
{
std::move(f),
LBANodeRef(),
[=, &t](auto &f, auto &lbarootref) {
- return get_root(t).safe_then(
+ return get_root(t).si_then(
[=, &t, &f](LBANodeRef lbaroot) mutable {
lbarootref = lbaroot;
return lbaroot->scan_mapped_space(
});
}
-BtreeLBAManager::rewrite_extent_ret BtreeLBAManager::rewrite_extent(
+BtreeLBAManager::rewrite_extent_ret BtreeLBAManager::_rewrite_extent(
Transaction &t,
CachedExtentRef extent)
{
ceph_assert(in.paddr == prev_addr);
ret.paddr = addr;
return ret;
- }).safe_then(
+ }).si_then(
[nlextent](auto) {},
- crimson::ct_error::enoent::handle([extent]() -> rewrite_extent_ret {
- ceph_assert(extent->has_been_invalidated());
- return crimson::ct_error::eagain::make();
- }),
- rewrite_extent_ertr::pass_further{},
+ rewrite_extent_iertr::pass_further{},
/* ENOENT in particular should be impossible */
crimson::ct_error::assert_all{
"Invalid error in BtreeLBAManager::rewrite_extent after update_mapping"
t,
nlba_extent->get_node_meta().depth,
nlba_extent->get_node_meta().begin,
- nlba_extent->get_paddr()).safe_then(
+ nlba_extent->get_paddr()).si_then(
[](auto) {},
- crimson::ct_error::enoent::handle([extent]() -> rewrite_extent_ret {
- ceph_assert(extent->has_been_invalidated());
- return crimson::ct_error::eagain::make();
- }),
- rewrite_extent_ertr::pass_further{},
+ rewrite_extent_iertr::pass_further{},
crimson::ct_error::assert_all{
"Invalid error in BtreeLBAManager::rewrite_extent update_internal_mapping"
});
} else {
- return rewrite_extent_ertr::now();
+ return rewrite_extent_iertr::now();
}
}
BtreeLBAManager::get_physical_extent_if_live_ret
-BtreeLBAManager::get_physical_extent_if_live(
+BtreeLBAManager::_get_physical_extent_if_live(
Transaction &t,
extent_types_t type,
paddr_t addr,
addr,
laddr,
len
- ).safe_then([=, &t](CachedExtentRef extent) {
- return get_root(t).safe_then([=, &t](LBANodeRef root) {
+ ).si_then([=, &t](CachedExtentRef extent) {
+ return get_root(t).si_then([=, &t](LBANodeRef root) {
auto lba_node = extent->cast<LBANode>();
return root->lookup(
op_context_t{cache, pin_set, t},
lba_node->get_node_meta().begin,
- lba_node->get_node_meta().depth).safe_then([=](LBANodeRef c) {
+ lba_node->get_node_meta().depth).si_then([=](LBANodeRef c) {
if (c->get_paddr() == lba_node->get_paddr()) {
return get_physical_extent_if_live_ret(
- get_physical_extent_if_live_ertr::ready_future_marker{},
+ interruptible::ready_future_marker{},
lba_node);
} else {
cache.drop_from_cache(lba_node);
return get_physical_extent_if_live_ret(
- get_physical_extent_if_live_ertr::ready_future_marker{},
+ interruptible::ready_future_marker{},
CachedExtentRef());
}
});
laddr_t laddr,
lba_map_val_t val)
{
- auto split = insert_mapping_ertr::future<LBANodeRef>(
- insert_mapping_ertr::ready_future_marker{},
+ auto split = insert_mapping_iertr::future<LBANodeRef>(
+ interruptible::ready_future_marker{},
root);
if (root->at_max_capacity()) {
- split = cache.get_root(t).safe_then(
+ split = cache.get_root(t).si_then(
[this, root, laddr, &t](RootBlockRef croot) {
logger().debug(
"BtreeLBAManager::insert_mapping: splitting root {}",
laddr, nroot->begin(), root);
});
}
- return split.safe_then([this, &t, laddr, val](LBANodeRef node) {
+ return split.si_then([this, &t, laddr, val](LBANodeRef node) {
return node->insert(
get_context(t),
laddr, val);
ceph_assert((int)out.refcount + delta >= 0);
out.refcount += delta;
return out;
- }).safe_then([](auto result) {
+ }).si_then([](auto result) {
return ref_update_result_t{
result.refcount,
result.paddr,
update_func_t &&f)
{
return get_root(t
- ).safe_then([this, f=std::move(f), &t, addr](LBANodeRef root) mutable {
+ ).si_then([this, f=std::move(f), &t, addr](LBANodeRef root) mutable {
return root->mutate_mapping(
get_context(t),
addr,
laddr_t laddr,
paddr_t paddr)
{
- return cache.get_root(t).safe_then([=, &t](RootBlockRef croot) {
+ return cache.get_root(t).si_then([=, &t](RootBlockRef croot) {
if (depth == croot->get_root().lba_root.get_depth()) {
logger().debug(
"update_internal_mapping: updating lba root to: {}->{}",
auto old_paddr = croot->get_root().lba_root.get_location();
croot->get_root().lba_root.set_location(paddr);
return update_internal_mapping_ret(
- update_internal_mapping_ertr::ready_future_marker{},
+ interruptible::ready_future_marker{},
old_paddr);
} else {
logger().debug(
croot,
croot->get_root().lba_root.get_depth(),
croot->get_root().lba_root.get_location(),
- paddr_t()).safe_then([=, &t](LBANodeRef broot) {
+ paddr_t()).si_then([=, &t](LBANodeRef broot) {
return broot->mutate_internal_address(
get_context(t),
depth,
mkfs_ret mkfs(
Transaction &t) final;
- get_mappings_ret get_mappings(
+ get_mappings_ret _get_mappings(
Transaction &t,
laddr_t offset, extent_len_t length) final;
- get_mappings_ret get_mappings(
+ get_mappings_ret _get_mappings(
Transaction &t,
laddr_list_t &&list) final;
- get_mapping_ret get_mapping(
+ get_mapping_ret _get_mapping(
Transaction &t,
laddr_t offset) final;
- find_hole_ret find_hole(
+ find_hole_ret _find_hole(
Transaction &t,
laddr_t hint,
extent_len_t) final;
- alloc_extent_ret alloc_extent(
+ alloc_extent_ret _alloc_extent(
Transaction &t,
laddr_t hint,
extent_len_t len,
paddr_t addr) final;
- set_extent_ret set_extent(
+ set_extent_ret _set_extent(
Transaction &t,
laddr_t off, extent_len_t len, paddr_t addr) final;
- ref_ret decref_extent(
+ ref_ret _decref_extent(
Transaction &t,
laddr_t addr) final {
return update_refcount(t, addr, -1);
}
- ref_ret incref_extent(
+ ref_ret _incref_extent(
Transaction &t,
laddr_t addr) final {
return update_refcount(t, addr, 1);
void complete_transaction(
Transaction &t) final;
- init_cached_extent_ret init_cached_extent(
+ init_cached_extent_ret _init_cached_extent(
Transaction &t,
CachedExtentRef e) final;
- scan_mappings_ret scan_mappings(
+ scan_mappings_ret _scan_mappings(
Transaction &t,
laddr_t begin,
laddr_t end,
scan_mappings_func_t &&f) final;
- scan_mapped_space_ret scan_mapped_space(
+ scan_mapped_space_ret _scan_mapped_space(
Transaction &t,
scan_mapped_space_func_t &&f) final;
- rewrite_extent_ret rewrite_extent(
+ rewrite_extent_ret _rewrite_extent(
Transaction &t,
- CachedExtentRef extent);
+ CachedExtentRef extent) final;
- get_physical_extent_if_live_ret get_physical_extent_if_live(
+ get_physical_extent_if_live_ret _get_physical_extent_if_live(
Transaction &t,
extent_types_t type,
paddr_t addr,
~BtreeLBAManager();
private:
SegmentManager &segment_manager;
- InterruptedCache cache;
+ Cache &cache;
btree_pin_set_t pin_set;
*
* Get a reference to the root LBANode.
*/
- using get_root_ertr = base_ertr;
- using get_root_ret = get_root_ertr::future<LBANodeRef>;
+ using get_root_iertr = base_iertr;
+ using get_root_ret = get_root_iertr::future<LBANodeRef>;
get_root_ret get_root(Transaction &);
/**
*
* Insert a lba mapping into the tree
*/
- using insert_mapping_ertr = base_ertr;
- using insert_mapping_ret = insert_mapping_ertr::future<LBAPinRef>;
+ using insert_mapping_iertr = base_iertr;
+ using insert_mapping_ret = insert_mapping_iertr::future<LBAPinRef>;
insert_mapping_ret insert_mapping(
Transaction &t, ///< [in,out] transaction
LBANodeRef root, ///< [in] root node
*
* Updates mapping, removes if f returns nullopt
*/
- using update_mapping_ertr = ref_ertr;
- using update_mapping_ret = ref_ertr::future<lba_map_val_t>;
+ using update_mapping_iertr = ref_iertr;
+ using update_mapping_ret = ref_iertr::future<lba_map_val_t>;
using update_func_t = LBANode::mutate_func_t;
update_mapping_ret update_mapping(
Transaction &t,
laddr_t addr,
update_func_t &&f);
- using update_internal_mapping_ertr = LBANode::mutate_internal_address_ertr;
+ using update_internal_mapping_iertr = LBANode::mutate_internal_address_iertr;
using update_internal_mapping_ret = LBANode::mutate_internal_address_ret;
update_internal_mapping_ret update_internal_mapping(
Transaction &t,
namespace crimson::os::seastore::lba_manager::btree {
-using base_ertr = LBAManager::base_ertr;
+using base_iertr = LBAManager::base_iertr;
struct op_context_t {
- InterruptedCache cache;
+ Cache &cache;
btree_pin_set_t &pins;
Transaction &trans;
};
* Returns the node at the specified depth responsible
* for laddr
*/
- using lookup_ertr = base_ertr;
- using lookup_ret = lookup_ertr::future<LBANodeRef>;
+ using lookup_iertr = base_iertr;
+ using lookup_ret = lookup_iertr::future<LBANodeRef>;
virtual lookup_ret lookup(
op_context_t c,
laddr_t addr,
*
* Returns mappings within range [addr, addr+len)
*/
- using lookup_range_ertr = LBAManager::get_mappings_ertr;
+ using lookup_range_iertr = LBAManager::get_mappings_iertr;
using lookup_range_ret = LBAManager::get_mappings_ret;
virtual lookup_range_ret lookup_range(
op_context_t c,
*
* Returns the mapping at addr
*/
- using lookup_pin_ertr = LBAManager::get_mapping_ertr;
+ using lookup_pin_iertr = LBAManager::get_mapping_iertr;
using lookup_pin_ret = LBAManager::get_mapping_ret;
virtual lookup_pin_ret lookup_pin(
op_context_t c,
*
* Precondition: !at_max_capacity()
*/
- using insert_ertr = base_ertr;
- using insert_ret = insert_ertr::future<LBAPinRef>;
+ using insert_iertr = base_iertr;
+ using insert_ret = insert_iertr::future<LBAPinRef>;
virtual insert_ret insert(
op_context_t c,
laddr_t laddr,
*
* @return addr of hole, L_ADDR_NULL if unfound
*/
- using find_hole_ertr = base_ertr;
- using find_hole_ret = find_hole_ertr::future<laddr_t>;
+ using find_hole_iertr = base_iertr;
+ using find_hole_ret = find_hole_iertr::future<laddr_t>;
virtual find_hole_ret find_hole(
op_context_t c,
laddr_t min,
*
* Call f for all mappings in [begin, end)
*/
- using scan_mappings_ertr = LBAManager::scan_mappings_ertr;
+ using scan_mappings_iertr = LBAManager::scan_mappings_iertr;
using scan_mappings_ret = LBAManager::scan_mappings_ret;
using scan_mappings_func_t = LBAManager::scan_mappings_func_t;
virtual scan_mappings_ret scan_mappings(
laddr_t end,
scan_mappings_func_t &f) = 0;
- using scan_mapped_space_ertr = LBAManager::scan_mapped_space_ertr;
+ using scan_mapped_space_iertr = LBAManager::scan_mapped_space_iertr;
using scan_mapped_space_ret = LBAManager::scan_mapped_space_ret;
using scan_mapped_space_func_t = LBAManager::scan_mapped_space_func_t;
virtual scan_mapped_space_ret scan_mapped_space(
*
* Precondition: !at_min_capacity()
*/
- using mutate_mapping_ertr = base_ertr::extend<
+ using mutate_mapping_iertr = base_iertr::extend<
crimson::ct_error::enoent ///< mapping does not exist
>;
- using mutate_mapping_ret = mutate_mapping_ertr::future<
+ using mutate_mapping_ret = mutate_mapping_iertr::future<
lba_map_val_t>;
using mutate_func_t = std::function<
lba_map_val_t(const lba_map_val_t &v)
* updates the mapping to paddr. Returns previous paddr
* (for debugging purposes).
*/
- using mutate_internal_address_ertr = base_ertr::extend<
+ using mutate_internal_address_iertr = base_iertr::extend<
crimson::ct_error::enoent ///< mapping does not exist
>;
- using mutate_internal_address_ret = mutate_internal_address_ertr::future<
+ using mutate_internal_address_ret = mutate_internal_address_iertr::future<
paddr_t>;
virtual mutate_internal_address_ret mutate_internal_address(
op_context_t c,
*
* Fetches node at depth of the appropriate type.
*/
-using get_lba_node_ertr = base_ertr;
-using get_lba_node_ret = get_lba_node_ertr::future<LBANodeRef>;
+using get_lba_node_iertr = base_iertr;
+using get_lba_node_ret = get_lba_node_iertr::future<LBANodeRef>;
get_lba_node_ret get_lba_btree_extent(
op_context_t c, ///< [in] context structure
CachedExtentRef parent, ///< [in] paddr ref source
auto meta = get_meta();
if (depth == get_meta().depth) {
return lookup_ret(
- lookup_ertr::ready_future_marker{},
+ interruptible::ready_future_marker{},
this);
}
assert(meta.begin <= addr);
this,
meta.depth - 1,
iter->get_val(),
- get_paddr()).safe_then([c, addr, depth](auto child) {
+ get_paddr()).si_then([c, addr, depth](auto child) {
return child->lookup(c, addr, depth);
}).finally([ref=LBANodeRef(this)] {});
}
auto [begin, end] = bound(addr, addr + len);
auto result_up = std::make_unique<lba_pin_list_t>();
auto &result = *result_up;
- return crimson::do_for_each(
+ return trans_intr::do_for_each(
std::move(begin),
std::move(end),
- [this, c, &result, addr, len](const auto &val) mutable {
+ [this, c, &result, addr, len](const auto &val) {
return get_lba_btree_extent(
c,
this,
get_meta().depth - 1,
val.get_val(),
- get_paddr()).safe_then(
- [c, &result, addr, len](auto extent) mutable {
+ get_paddr()).si_then(
+ [c, &result, addr, len](auto extent) {
return extent->lookup_range(
c,
addr,
- len).safe_then(
- [&result](auto pin_list) mutable {
+ len).si_then(
+ [&result](auto pin_list) {
result.splice(result.end(), pin_list,
pin_list.begin(), pin_list.end());
});
});
- }).safe_then([result=std::move(result_up), ref=LBANodeRef(this)] {
- return lookup_range_ertr::make_ready_future<lba_pin_list_t>(
+ }).si_then([result=std::move(result_up), ref=LBANodeRef(this)] {
+ return lookup_range_iertr::make_ready_future<lba_pin_list_t>(
std::move(*result));
});
}
get_meta().depth - 1,
iter->get_val(),
get_paddr()
- ).safe_then([c, addr] (LBANodeRef extent) {
+ ).si_then([c, addr](LBANodeRef extent) {
return extent->lookup_pin(c, addr);
}).finally([ref=LBANodeRef(this)] {});
}
this,
get_meta().depth - 1,
insertion_pt->get_val(),
- get_paddr()).safe_then(
+ get_paddr()).si_then(
[this, insertion_pt, c, laddr, val=std::move(val)](
auto extent) mutable {
return extent->at_max_capacity() ?
split_entry(c, laddr, insertion_pt, extent) :
- insert_ertr::make_ready_future<LBANodeRef>(std::move(extent));
- }).safe_then([c, laddr, val=std::move(val)](
+ insert_iertr::make_ready_future<LBANodeRef>(std::move(extent));
+ }).si_then([c, laddr, val=std::move(val)](
LBANodeRef extent) mutable {
return extent->insert(c, laddr, val);
});
get_meta().depth - 1,
mutation_pt->get_val(),
get_paddr()
- ).safe_then([=](LBANodeRef extent) {
+ ).si_then([=](LBANodeRef extent) {
if (extent->at_min_capacity() && get_size() > 1) {
return merge_entry(
c,
extent,
is_root);
} else {
- return merge_ertr::make_ready_future<LBANodeRef>(
+ return merge_iertr::make_ready_future<LBANodeRef>(
std::move(extent));
}
- }).safe_then([c, laddr, f=std::move(f)](LBANodeRef extent) mutable {
+ }).si_then([c, laddr, f=std::move(f)](LBANodeRef extent) mutable {
return extent->mutate_mapping_internal(c, laddr, false, std::move(f));
});
}
maybe_get_delta_buffer());
return mutate_internal_address_ret(
- mutate_internal_address_ertr::ready_future_marker{},
+ interruptible::ready_future_marker{},
old_paddr
);
} else {
get_meta().depth - 1,
iter->get_val(),
get_paddr()
- ).safe_then([=](auto node) {
+ ).si_then([=](auto node) {
return node->mutate_internal_address(
c,
depth,
begin,
L_ADDR_NULL,
[this, c, min_addr, len, end=end](auto &i, auto &ret) {
- return crimson::repeat([=, &i, &ret]()
- -> find_hole_ertr::future<seastar::stop_iteration> {
+ return trans_intr::repeat([=, &i, &ret]()
+ -> find_hole_iertr::future<seastar::stop_iteration> {
if (i == end) {
return seastar::make_ready_future<seastar::stop_iteration>(
seastar::stop_iteration::yes);
get_meta().depth - 1,
i->get_val(),
get_paddr()
- ).safe_then([=, &i](auto extent) mutable {
+ ).si_then([=, &i](auto extent) mutable {
auto lb = std::max(min_addr, i->get_key());
auto ub = i->get_next_key_or_max();
logger().debug("LBAInternalNode::find_hole extent {} lb {} ub {}",
*extent, lb, ub);
return extent->find_hole(c, lb, ub, len);
- }).safe_then([&i, &ret](auto addr) mutable {
+ }).si_then([&i, &ret](auto addr) {
if (addr == L_ADDR_NULL) {
++i;
return seastar::make_ready_future<seastar::stop_iteration>(
seastar::stop_iteration::yes);
}
});
- }).safe_then([&ret, ref=LBANodeRef(this)] {
- return ret;
- });
- });
+ }).si_then([&ret, ref=LBANodeRef(this)]() {
+ return ret;
+ });
+ });
}
LBAInternalNode::scan_mappings_ret LBAInternalNode::scan_mappings(
scan_mappings_func_t &f)
{
auto [biter, eiter] = bound(begin, end);
- return crimson::do_for_each(
+ return trans_intr::do_for_each(
std::move(biter),
std::move(eiter),
[=, &f](auto &viter) {
this,
get_meta().depth - 1,
viter->get_val(),
- get_paddr()).safe_then([=, &f](auto child) {
+ get_paddr()).si_then([=, &f](auto child) {
return child->scan_mappings(c, begin, end, f);
});
- }).safe_then([ref=LBANodeRef(this)]{});
+ }).si_then([ref=LBANodeRef(this)] {});
}
LBAInternalNode::scan_mapped_space_ret LBAInternalNode::scan_mapped_space(
scan_mapped_space_func_t &f)
{
f(get_paddr(), get_length());
- return crimson::do_for_each(
+ return trans_intr::do_for_each(
begin(), end(),
[=, &f](auto &viter) {
return get_lba_btree_extent(
this,
get_meta().depth - 1,
viter->get_val(),
- get_paddr()).safe_then([=, &f](auto child) {
+ get_paddr()).si_then([=, &f](auto child) {
return child->scan_mapped_space(c, f);
});
- }).safe_then([ref=LBANodeRef(this)]{});
+ }).si_then([ref=LBANodeRef(this)]{});
}
*left,
*right);
- return split_ertr::make_ready_future<LBANodeRef>(
+ return split_iertr::make_ready_future<LBANodeRef>(
pivot > addr ? left : right
);
}
get_meta().depth - 1,
donor_iter->get_val(),
get_paddr()
- ).safe_then([=](auto donor) mutable {
+ ).si_then([=](auto donor) mutable {
auto [l, r] = donor_is_left ?
std::make_pair(donor, entry) : std::make_pair(entry, donor);
auto [liter, riter] = donor_is_left ?
c.cache.retire_extent(c.trans, r);
if (is_root && get_size() == 1) {
- return c.cache.get_root(c.trans).safe_then([=](RootBlockRef croot) {
+ return c.cache.get_root(c.trans).si_then([=](RootBlockRef croot) {
{
auto mut_croot = c.cache.duplicate_for_write(c.trans, croot);
croot = mut_croot->cast<RootBlock>();
*this,
new_root_addr);
c.cache.retire_extent(c.trans, this);
- return merge_ertr::make_ready_future<LBANodeRef>(replacement);
+ return merge_iertr::make_ready_future<LBANodeRef>(replacement);
});
} else {
- return merge_ertr::make_ready_future<LBANodeRef>(replacement);
+ return merge_iertr::make_ready_future<LBANodeRef>(replacement);
}
} else {
logger().debug(
c.cache.retire_extent(c.trans, l);
c.cache.retire_extent(c.trans, r);
- return merge_ertr::make_ready_future<LBANodeRef>(
+ return merge_iertr::make_ready_future<LBANodeRef>(
addr >= pivot ? replacement_r : replacement_l
);
}
val.paddr.maybe_relative_to(get_paddr()),
lba_node_meta_t{ begin, begin + val.len, 0}));
}
- return lookup_range_ertr::make_ready_future<lba_pin_list_t>(
+ return lookup_range_iertr::make_ready_future<lba_pin_list_t>(
std::move(ret));
}
auto val = iter->get_val();
auto begin = iter->get_key();
return lookup_pin_ret(
- lookup_pin_ertr::ready_future_marker{},
+ interruptible::ready_future_marker{},
std::make_unique<BtreeLBAPin>(
this,
val.paddr.maybe_relative_to(get_paddr()),
insert_pt.get_val().paddr);
auto begin = insert_pt.get_key();
return insert_ret(
- insert_ertr::ready_future_marker{},
+ interruptible::ready_future_marker{},
std::make_unique<BtreeLBAPin>(
this,
val.paddr.maybe_relative_to(get_paddr()),
if (mutated.refcount > 0) {
journal_update(mutation_pt, mutated, maybe_get_delta_buffer());
return mutate_mapping_ret(
- mutate_mapping_ertr::ready_future_marker{},
+ interruptible::ready_future_marker{},
mutated);
} else {
journal_remove(mutation_pt, maybe_get_delta_buffer());
return mutate_mapping_ret(
- mutate_mapping_ertr::ready_future_marker{},
+ interruptible::ready_future_marker{},
mutated);
}
}
{
ceph_assert(0 == "Impossible");
return mutate_internal_address_ret(
- mutate_internal_address_ertr::ready_future_marker{},
+ interruptible::ready_future_marker{},
paddr);
}
auto ub = i->get_key();
if (min + len <= ub) {
return find_hole_ret(
- find_hole_ertr::ready_future_marker{},
+ interruptible::ready_future_marker{},
min);
} else {
min = i->get_key() + i->get_val().len;
}
if (min + len <= max) {
return find_hole_ret(
- find_hole_ertr::ready_future_marker{},
+ interruptible::ready_future_marker{},
min);
} else {
return find_hole_ret(
- find_hole_ertr::ready_future_marker{},
+ interruptible::ready_future_marker{},
L_ADDR_MAX);
}
}
auto val = i->get_val();
f(i->get_key(), val.paddr, val.len);
}
- return scan_mappings_ertr::now();
+ return scan_mappings_iertr::now();
}
LBALeafNode::scan_mapped_space_ret LBALeafNode::scan_mapped_space(
auto val = i->get_val();
f(val.paddr, val.len);
}
- return scan_mappings_ertr::now();
+ return scan_mappings_iertr::now();
}
return c.cache.get_extent<LBAInternalNode>(
c.trans,
offset,
- LBA_BLOCK_SIZE).safe_then([c, parent](auto ret)
+ LBA_BLOCK_SIZE).si_then([c, parent](auto ret)
-> get_lba_node_ret {
auto meta = ret->get_meta();
if (ret->get_size()) {
ceph_assert(meta.begin <= ret->begin()->get_key());
ceph_assert(meta.end > (ret->end() - 1)->get_key());
}
- if (parent->has_been_invalidated() || ret->has_been_invalidated()) {
- return crimson::ct_error::eagain::make();
- }
+ assert(!(parent->has_been_invalidated() || ret->has_been_invalidated()));
if (!ret->is_pending() && !ret->pin.is_linked()) {
ret->pin.set_range(meta);
c.pins.add_pin(ret->pin);
}
return get_lba_node_ret(
- get_lba_node_ertr::ready_future_marker{},
+ interruptible::ready_future_marker{},
LBANodeRef(ret.detach(), /* add_ref = */ false));
});
} else {
return c.cache.get_extent<LBALeafNode>(
c.trans,
offset,
- LBA_BLOCK_SIZE).safe_then([offset, c, parent](auto ret)
+ LBA_BLOCK_SIZE).si_then([offset, c, parent](auto ret)
-> get_lba_node_ret {
logger().debug(
"get_lba_btree_extent: read leaf at offset {} {}, parent {}",
ceph_assert(meta.begin <= ret->begin()->get_key());
ceph_assert(meta.end > (ret->end() - 1)->get_key());
}
- if (parent->has_been_invalidated() || ret->has_been_invalidated()) {
- return crimson::ct_error::eagain::make();
- }
+ assert(!(parent->has_been_invalidated() || ret->has_been_invalidated()));
if (!ret->is_pending() && !ret->pin.is_linked()) {
ret->pin.set_range(meta);
c.pins.add_pin(ret->pin);
}
return get_lba_node_ret(
- get_lba_node_ertr::ready_future_marker{},
+ interruptible::ready_future_marker{},
LBANodeRef(ret.detach(), /* add_ref = */ false));
});
}
return std::make_pair(retl, retr);
}
- using split_ertr = base_ertr;
- using split_ret = split_ertr::future<LBANodeRef>;
+ using split_iertr = base_iertr;
+ using split_ret = split_iertr::future<LBANodeRef>;
split_ret split_entry(
op_context_t c,
laddr_t addr,
internal_iterator_t,
LBANodeRef entry);
- using merge_ertr = base_ertr;
- using merge_ret = merge_ertr::future<LBANodeRef>;
+ using merge_iertr = base_iertr;
+ using merge_ret = merge_iertr::future<LBANodeRef>;
merge_ret merge_entry(
op_context_t c,
laddr_t addr,
lookup_ret lookup(op_context_t c, laddr_t addr, depth_t depth) final
{
return lookup_ret(
- lookup_ertr::ready_future_marker{},
+ interruptible::ready_future_marker{},
this);
}
* Get the logical pin at offset
*/
using get_pin_ertr = LBAManager::get_mapping_ertr;
- using get_pin_ret = LBAManager::get_mapping_ret;
+ using get_pin_ret = LBAManager::get_mapping_ertr::future<LBAPinRef>;
get_pin_ret get_pin(
Transaction &t,
laddr_t offset) {
}
using find_hole_ertr = LBAManager::find_hole_ertr;
- using find_hole_ret = LBAManager::find_hole_ret;
+ using find_hole_ret = LBAManager::find_hole_ertr::future<
+ std::pair<laddr_t, extent_len_t>
+ >;
find_hole_ret find_hole(
Transaction &t,
laddr_t hint,
projects / ceph.git / commitdiff