extent->get_paddr(),
nullptr // all the extents should have already been
// added to the fixed_kv_btree
- );
+ ).discard_result();
});
}
laddr_t hint,
extent_len_t len,
paddr_t addr,
- LogicalCachedExtent &nextent) = 0;
+ LogicalCachedExtent &nextent,
+ extent_ref_count_t refcount = EXTENT_DEFAULT_REF_COUNT) = 0;
virtual alloc_extent_ret clone_mapping(
Transaction &t,
* update lba mapping for a delayed allocated extent
*/
using update_mapping_iertr = base_iertr;
- using update_mapping_ret = base_iertr::future<>;
+ using update_mapping_ret = base_iertr::future<extent_ref_count_t>;
virtual update_mapping_ret update_mapping(
Transaction& t,
laddr_t laddr,
* update lba mappings for delayed allocated extents
*/
using update_mappings_iertr = update_mapping_iertr;
- using update_mappings_ret = update_mapping_ret;
+ using update_mappings_ret = update_mappings_iertr::future<>;
update_mappings_ret update_mappings(
Transaction& t,
const std::list<LogicalCachedExtentRef>& extents);
extent_len_t len,
pladdr_t addr,
paddr_t actual_addr,
- LogicalCachedExtent* nextent)
+ LogicalCachedExtent* nextent,
+ extent_ref_count_t refcount)
{
struct state_t {
laddr_t last_end;
};
LOG_PREFIX(BtreeLBAManager::_alloc_extent);
- TRACET("{}~{}, hint={}", t, addr, len, hint);
+ TRACET("{}~{}, hint={}, refcount={}", t, addr, len, hint, refcount);
ceph_assert(actual_addr != P_ADDR_NULL ? addr.is_laddr() : addr.is_paddr());
auto c = get_context(t);
c,
hint,
[this, FNAME, c, hint, len, addr, lookup_attempts,
- &t, nextent](auto &btree, auto &state) {
+ &t, nextent, refcount](auto &btree, auto &state) {
return LBABtree::iterate_repeat(
c,
btree.upper_bound_right(c, hint),
interruptible::ready_future_marker{},
seastar::stop_iteration::no);
}
- }).si_then([FNAME, c, addr, len, hint, &btree, &state, nextent] {
+ }).si_then([FNAME, c, addr, len, hint, &btree, &state, nextent, refcount] {
return btree.insert(
c,
*state.insert_iter,
state.last_end,
- lba_map_val_t{len, pladdr_t(addr), 1, 0},
+ lba_map_val_t{len, pladdr_t(addr), refcount, 0},
nextent
).si_then([&state, FNAME, c, addr, len, hint, nextent](auto &&p) {
auto [iter, inserted] = std::move(p);
auto &result = res.map_value;
DEBUGT("laddr={}, paddr {} => {} done -- {}",
t, laddr, prev_addr, addr, result);
+ return update_mapping_iertr::make_ready_future<
+ extent_ref_count_t>(result.refcount);
},
update_mapping_iertr::pass_further{},
/* ENOENT in particular should be impossible */
len,
P_ADDR_ZERO,
P_ADDR_NULL,
- nullptr);
+ nullptr,
+ EXTENT_DEFAULT_REF_COUNT);
}
alloc_extent_ret clone_mapping(
len,
intermediate_key,
actual_addr,
- nullptr
+ nullptr,
+ EXTENT_DEFAULT_REF_COUNT
).si_then([&t, this, intermediate_base](auto indirect_mapping) {
assert(indirect_mapping->is_indirect());
return update_refcount(t, intermediate_base, 1, false
laddr_t hint,
extent_len_t len,
paddr_t addr,
- LogicalCachedExtent &ext) final
+ LogicalCachedExtent &ext,
+ extent_ref_count_t refcount = EXTENT_DEFAULT_REF_COUNT) final
{
return _alloc_extent(
t,
len,
addr,
P_ADDR_NULL,
- &ext);
+ &ext,
+ refcount);
}
ref_ret decref_extent(
extent_len_t len,
pladdr_t addr,
paddr_t actual_addr,
- LogicalCachedExtent*);
+ LogicalCachedExtent*,
+ extent_ref_count_t refcount);
using _get_mapping_ret = get_mapping_iertr::future<BtreeLBAMappingRef>;
_get_mapping_ret _get_mapping(
lextent->get_paddr(),
nlextent->get_length(),
nlextent->get_paddr(),
- nlextent.get());
+ nlextent.get()).discard_result();
} else {
assert(get_extent_category(lextent->get_type()) == data_category_t::DATA);
auto extents = cache->alloc_new_data_extents_by_type(
std::move(extents),
0,
lextent->get_length(),
- [this, lextent, &t](auto &extents, auto &off, auto &left) {
+ extent_ref_count_t(0),
+ [this, lextent, &t](auto &extents, auto &off, auto &left, auto &refcount) {
return trans_intr::do_for_each(
extents,
- [lextent, this, &t, &off, &left](auto &nextent) {
+ [lextent, this, &t, &off, &left, &refcount](auto &nextent) {
LOG_PREFIX(TransactionManager::rewrite_logical_extent);
bool first_extent = (off == 0);
ceph_assert(left >= nextent->get_length());
lextent->get_paddr(),
nlextent->get_length(),
nlextent->get_paddr(),
- nlextent.get());
+ nlextent.get()
+ ).si_then([&refcount](auto c) {
+ refcount = c;
+ });
} else {
+ ceph_assert(refcount != 0);
fut = lba_manager->alloc_extent(
t,
lextent->get_laddr() + off,
nlextent->get_length(),
nlextent->get_paddr(),
- *nlextent
+ *nlextent,
+ refcount
).si_then([lextent, nlextent, off](auto mapping) {
ceph_assert(mapping->get_key() == lextent->get_laddr() + off);
ceph_assert(mapping->get_val() == nlextent->get_paddr());