assert(!is_end());
auto val = get_val();
auto key = get_key();
+ node_key_t end{};
+ if constexpr (std::is_same_v<node_key_t, laddr_t>) {
+ end = (key + val.len).checked_to_laddr();
+ } else {
+ end = key + val.len;
+ }
return std::make_unique<pin_t>(
ctx,
leaf.node,
leaf.pos,
val,
- fixed_kv_node_meta_t<node_key_t>{ key, key + val.len, 0 });
+ fixed_kv_node_meta_t<node_key_t>{ key, end, 0 });
}
typename leaf_node_t::Ref get_leaf_node() {
void on_rewrite(Transaction&, CachedExtent &extent, extent_len_t off) final {
assert(get_type() == extent.get_type());
auto &lextent = (LogicalCachedExtent&)extent;
- set_laddr(lextent.get_laddr() + off);
+ set_laddr((lextent.get_laddr() + off).checked_to_laddr());
}
bool has_laddr() const {
assert((info.key == L_ADDR_NULL) == (laddr_null));
if (!laddr_null) {
assert(info.key >= last_end);
- last_end = info.key + info.len;
+ last_end = (info.key + info.len).checked_to_laddr();
}
}
#endif
interruptible::ready_future_marker{},
seastar::stop_iteration::yes);
} else {
- state.last_end = pos.get_key() + pos.get_val().len;
+ state.last_end = (pos.get_key() + pos.get_val().len).checked_to_laddr();
TRACET("{}~{}, hint={}, state: {}~{}, repeat ... -- {}",
t, addr, total_len, hint,
pos.get_key(), pos.get_val().len,
return iter.next(c).si_then([&state, &alloc_info](auto it) {
state.insert_iter = it;
if (alloc_info.key == L_ADDR_NULL) {
- state.last_end = state.last_end + alloc_info.len;
+ state.last_end = (state.last_end + alloc_info.len).checked_to_laddr();
}
});
});
: L_ADDR_NULL;
auto remap_offset = remap.offset;
auto remap_len = remap.len;
- auto remap_laddr = orig_laddr + remap_offset;
+ auto remap_laddr = (orig_laddr + remap_offset).checked_to_laddr();
ceph_assert(intermediate_base != L_ADDR_NULL);
ceph_assert(intermediate_key != L_ADDR_NULL);
ceph_assert(remap_len < orig_len);
" intermediate_base: {}, intermediate_key: {}", t,
remap_laddr, orig_paddr, remap_len,
intermediate_base, intermediate_key);
- auto remapped_intermediate_key = intermediate_key + remap_offset;
+ auto remapped_intermediate_key = (intermediate_key + remap_offset).checked_to_laddr();
alloc_infos.emplace_back(
alloc_mapping_info_t::create_indirect(
remap_laddr,
}
fut = alloc_cloned_mappings(
t,
- remaps.front().offset + orig_laddr,
+ (remaps.front().offset + orig_laddr).checked_to_laddr(),
std::move(alloc_infos)
).si_then([&orig_mapping](auto imappings) mutable {
std::vector<LBAMappingRef> mappings;
} else { // !orig_mapping->is_indirect()
fut = alloc_extents(
t,
- remaps.front().offset + orig_laddr,
+ (remaps.front().offset + orig_laddr).checked_to_laddr(),
std::move(extents),
EXTENT_DEFAULT_REF_COUNT);
}
this,
iter.get_offset(),
val,
- lba_node_meta_t{laddr, laddr + val.len, 0});
+ lba_node_meta_t{laddr, (laddr + val.len).checked_to_laddr(), 0});
}
}
}
laddr_t get_end_addr() const {
- return addr + len;
+ return (addr + len).checked_to_laddr();
}
static extent_to_write_t create_data(
off);
}
iter.copy(extent->get_length(), extent->get_bptr().c_str());
- off = off + extent->get_length();
+ off = (off + extent->get_length()).checked_to_laddr();
left -= extent->get_length();
}
return ObjectDataHandler::write_iertr::now();
extent_len_t block_size) :
data_base(data_base),
pin_begin(pins.front()->get_key()),
- pin_end(pins.back()->get_key() + pins.back()->get_length()),
+ pin_end((pins.back()->get_key() + pins.back()->get_length()).checked_to_laddr()),
left_paddr(pins.front()->get_val()),
right_paddr(pins.back()->get_val()),
data_begin(data_base + offset),
pin.get_key(),
size - pin_offset));
to_write.push_back(extent_to_write_t::create_zero(
- object_data.get_reserved_data_base() + roundup_size,
+ (object_data.get_reserved_data_base() + roundup_size).checked_to_laddr(),
object_data.get_reserved_data_len() - roundup_size));
return clear_iertr::now();
} else {
pin.get_key(),
bl));
to_write.push_back(extent_to_write_t::create_zero(
- object_data.get_reserved_data_base() + roundup_size,
+ (object_data.get_reserved_data_base() + roundup_size).checked_to_laddr(),
object_data.get_reserved_data_len() - roundup_size));
return clear_iertr::now();
});
ceph_assert(offset == last_pos);
auto fut = TransactionManager::alloc_extent_iertr
::make_ready_future<LBAMappingRef>();
- auto addr = object_data.get_reserved_data_base() + offset;
+ laddr_t addr = (object_data.get_reserved_data_base() + offset)
+ .checked_to_laddr();
if (pin->get_val().is_zero()) {
fut = ctx.tm.reserve_region(ctx.t, addr, pin->get_length());
} else {
if (last_pos != object_data.get_reserved_data_len()) {
return ctx.tm.reserve_region(
ctx.t,
- object_data.get_reserved_data_base() + last_pos,
+ (object_data.get_reserved_data_base() + last_pos).checked_to_laddr(),
object_data.get_reserved_data_len() - last_pos
).si_then([](auto) {
return seastar::now();
assert(default_metadata_offset);
assert(default_metadata_range);
uint64_t range_blocks = default_metadata_range / block_size;
- return get_hint() + default_metadata_offset +
- (((uint32_t)std::rand() % range_blocks) * block_size);
+ auto random_offset = default_metadata_offset +
+ (((uint32_t)std::rand() % range_blocks) * block_size);
+ return (get_hint() + random_offset).checked_to_laddr();
}
laddr_t get_data_hint() const {
return get_hint();
if (first_extent) {
fut = lba_manager->update_mapping(
t,
- lextent->get_laddr() + off,
+ (lextent->get_laddr() + off).checked_to_laddr(),
lextent->get_length(),
lextent->get_paddr(),
nlextent->get_length(),
ceph_assert(refcount != 0);
fut = lba_manager->alloc_extent(
t,
- lextent->get_laddr() + off,
+ (lextent->get_laddr() + off).checked_to_laddr(),
*nlextent,
refcount
).si_then([lextent, nlextent, off](auto mapping) {
for (auto &remap : remaps) {
auto remap_offset = remap.offset;
auto remap_len = remap.len;
- auto remap_laddr = original_laddr + remap_offset;
+ auto remap_laddr = (original_laddr + remap_offset).checked_to_laddr();
auto remap_paddr = original_paddr.add_offset(remap_offset);
ceph_assert(remap_len < original_len);
ceph_assert(remap_offset + remap_len <= original_len);
cur = i.first;
}
blret.append(i.second->get_bptr());
- cur += i.second->get_bptr().length();
+ cur = (cur + i.second->get_bptr().length()).checked_to_laddr();
}
if (blret.length() != size) {
assert(blret.length() < size);
bottom->first + bottom->second.len <= addr)
++bottom;
- auto top = t.mappings.lower_bound(addr + len);
+ auto top = t.mappings.lower_bound((addr + len).checked_to_laddr());
return std::make_pair(
bottom,
top
EXPECT_EQ(addr, last);
break;
}
- EXPECT_FALSE(iter->first - last > len);
- last = iter->first + iter->second.desc.len;
+ EXPECT_FALSE((iter->first - last).to_byte_offset() > len);
+ last = (iter->first + iter->second.desc.len).checked_to_laddr();
++iter;
}
}
o_len - new_offset - new_len)
}
).si_then([this, new_offset, new_len, o_laddr, &t, &bl](auto ret) {
- return tm->alloc_data_extents<TestBlock>(t, o_laddr + new_offset, new_len
+ return tm->alloc_data_extents<TestBlock>(t, (o_laddr + new_offset).checked_to_laddr(), new_len
).si_then([this, ret = std::move(ret), new_len,
new_offset, o_laddr, &t, &bl](auto extents) mutable {
assert(extents.size() == 1);
ceph_assert(ret.size() == 2);
auto iter = bl.cbegin();
iter.copy(new_len, ext->get_bptr().c_str());
- auto r_laddr = o_laddr + new_offset + new_len;
+ auto r_laddr = (o_laddr + new_offset + new_len).checked_to_laddr();
// old pins expired after alloc new extent, need to get it.
return tm->get_pin(t, o_laddr
).si_then([this, &t, ext = std::move(ext), r_laddr](auto lpin) mutable {
o_len - new_offset - new_len)
}
).si_then([this, new_offset, new_len, o_laddr, &t, &bl](auto ret) {
- return tm->alloc_data_extents<TestBlock>(t, o_laddr + new_offset, new_len
+ return tm->alloc_data_extents<TestBlock>(t, (o_laddr + new_offset).checked_to_laddr(), new_len
).si_then([this, ret = std::move(ret), new_offset, new_len,
o_laddr, &t, &bl](auto extents) mutable {
assert(extents.size() == 1);
ceph_assert(ret.size() == 1);
auto iter = bl.cbegin();
iter.copy(new_len, ext->get_bptr().c_str());
- auto r_laddr = o_laddr + new_offset + new_len;
+ auto r_laddr = (o_laddr + new_offset + new_len).checked_to_laddr();
return tm->get_pin(t, r_laddr
).si_then([ext = std::move(ext)](auto rpin) mutable {
return _overwrite_pin_iertr::make_ready_future<
new_offset)
}
).si_then([this, new_offset, new_len, o_laddr, &t, &bl](auto ret) {
- return tm->alloc_data_extents<TestBlock>(t, o_laddr + new_offset, new_len
+ return tm->alloc_data_extents<TestBlock>(t, (o_laddr + new_offset).checked_to_laddr(), new_len
).si_then([this, ret = std::move(ret), new_len, o_laddr, &t, &bl]
(auto extents) mutable {
assert(extents.size() == 1);
epm->prefill_fragmented_devices();
auto t = create_transaction();
for (int i = 0; i < 1991; i++) {
- auto extents = alloc_extents(t, ADDR + i * 16384, 16384, 'a');
+ auto extents = alloc_extents(t, (ADDR + i * 16384).checked_to_laddr(), 16384, 'a');
}
- alloc_extents_deemed_fail(t, ADDR + 1991 * 16384, 16384, 'a');
+ alloc_extents_deemed_fail(t, (ADDR + 1991 * 16384).checked_to_laddr(), 16384, 'a');
check_mappings(t);
check();
submit_transaction(std::move(t));