auto ep = take_exception_from_future();
// Any assert_* handler we have:
- // assert_failure, assert_all and assert_all_func_t
+ // assert_failure, assert_all, and assert_all_func_t
// are expected to return void since we actually abort in them.
// This is why we need a way to diffreciate between them and between
// non-aborting error handlers (e.g handle) - for that we use the dedicated
return std::move(fut);
}
- class assert_all {
- const char* const msg = nullptr;
- public:
- assert_all(const char* msg)
- : msg(msg) {
- }
- assert_all() = default;
-
- template <class ErrorT, EnableIf<ErrorT>...>
- no_touch_error_marker operator()(ErrorT&& raw_error) {
- using decayed_t = std::decay_t<ErrorT>;
- static_assert(contains_once_v<decayed_t>,
- "discarding disallowed ErrorT");
- decayed_t::error_t::handle([this] (auto&& error_v) {
- ceph_abort_msgf("%s: %s", msg ? msg : "", error_v.message().c_str());
- })(std::forward<ErrorT>(raw_error));
- return no_touch_error_marker{};
- }
- };
+ template <typename... Args>
+ static auto assert_all(fmt::format_string<Args...> fmt_str, Args&&... args) {
+ // Extract string_view before the lambda: the consteval format-string check
+ // already ran at the call site; re-passing fmt_str into fmt::format()
+ // inside a lambda would re-trigger the consteval constructor at runtime.
+ fmt::string_view sv = fmt_str;
+ return assert_all_func(
+ [sv, ...captured = std::forward<Args>(args)](const auto&) mutable {
+ ceph_abort_msg(fmt::vformat(sv, fmt::make_format_args(captured...)));
+ });
+ }
template <typename Func>
class assert_all_func_t {
}
};
- class assert_all {
- const char* const msg = nullptr;
- public:
- assert_all(const char* msg)
- : msg(msg) {
- }
- assert_all() = default;
-
- template <class ErrorT>
- no_touch_error_marker operator()(ErrorT&& raw_error) {
- using decayed_t = std::decay_t<ErrorT>;
- decayed_t::error_t::handle([this] (auto&& error_v) {
- ceph_abort_msgf("%s: %s", msg ? msg : "", error_v.message().c_str());
- })(std::forward<ErrorT>(raw_error));
+ template <typename... Args>
+ static auto assert_all(fmt::format_string<Args...> fmt_str, Args&&... args) {
+ fmt::string_view sv = fmt_str;
+ return [sv, ...captured = std::forward<Args>(args)](auto&&) mutable
+ -> no_touch_error_marker {
+ ceph_abort_msg(fmt::vformat(sv, fmt::make_format_args(captured...)));
return no_touch_error_marker{};
- }
- };
+ };
+ }
template <class ErrorFunc>
static decltype(auto) all_same_way(ErrorFunc&& error_func) {
return shard_stores.invoke_on_all([](auto &local_store) {
return seastar::do_for_each(local_store.mshard_stores, [](auto& mshard_store) {
return mshard_store->mount().handle_error(
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"Invalid error in CyanStore::mount"
- });
+ ));
});
});
}
if (should_trim_alloc()) {
return trim_alloc(
).handle_error(
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"encountered invalid error in trim_alloc"
- }
+ )
);
} else {
return seastar::now();
if (should_start_trim_dirty()) {
return trim_dirty(
).handle_error(
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"encountered invalid error in trim_dirty"
- }
+ )
);
} else {
return seastar::now();
return sm_group->release_segment(segment_to_release
).handle_error(
clean_space_ertr::pass_further{},
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"SegmentCleaner::clean_space encountered invalid error in release_segment"
- }
+ )
).safe_then([this, FNAME, segment_to_release] {
auto old_usage = calc_utilization(segment_to_release);
if(unlikely(old_usage != 0)) {
return mount_ertr::now();
}),
crimson::ct_error::input_output_error::pass_further{},
- crimson::ct_error::assert_all{"unexpected error"}
+ crimson::ct_error::assert_all("unexpected error")
);
}).safe_then([this, FNAME] {
INFO("done, {}", segments);
return it->open(
).handle_error(
crimson::ct_error::input_output_error::pass_further(),
- crimson::ct_error::assert_all{
- "Invalid error when opening RBM"}
+ crimson::ct_error::assert_all(
+ "Invalid error when opening RBM")
);
});
});
return mkfs_iertr::now();
}).handle_error_interruptible(
mkfs_iertr::pass_further{},
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"Invalid error in BtreeBackrefManager::mkfs"
- }
+ )
);
}
return mkfs_iertr::now();
}).handle_error_interruptible(
mkfs_iertr::pass_further{},
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"Invalid error in Cache::mkfs"
- }
+ )
);
}
delta.paddr)
).handle_error(
replay_delta_ertr::pass_further{},
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"Invalid error in Cache::replay_delta"
- }
+ )
);
return extent_fut.safe_then([=, this, &delta](auto extent) {
if (!extent) {
});
}).handle_error_interruptible(
init_cached_extents_iertr::pass_further{},
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"Invalid error in Cache::init_cached_extents"
- }
+ )
).si_then([this, FNAME, &t] {
SUBINFOT(seastore_cache,
"finish with {}(0x{:x}B) extents, {} dirty, dirty_from={}, alloc_from={}",
std::move(extent));
},
get_extent_ertr::pass_further{},
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"Cache::read_extent: invalid error"
- }
+ )
);
}
futs, [](auto &fut) { return std::move(fut);
}).handle_error(
get_extent_ertr::pass_further{},
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"Cache::read_extent: invalid error"
- }
+ )
);
for (auto &ext : extents_read) {
auto &extent = ext.extent;
[this] {
return main_cleaner->clean_space(
).handle_error(
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"run_cleaner_until_done encountered error in clean_space"
- }
+ )
);
}
).finally([FNAME] {
main_cleaner_should_fast_evict());
return main_cleaner->clean_space(
).handle_error(
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"do_background_cycle encountered invalid error in main clean_space"
- }
+ )
).finally([this, main_cold_usage, FNAME] {
DEBUG("finished clean main");
abort_cold_usage(main_cold_usage, true);
should_clean_cold_for_main);
return cold_cleaner->clean_space(
).handle_error(
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"do_background_cycle encountered invalid error in cold clean_space"
- }
+ )
).finally([FNAME] {
DEBUG("finished clean cold");
});
return info.rbm->write(info.offset, info.bp
).handle_error(
alloc_write_ertr::pass_further{},
- crimson::ct_error::assert_all{
- "Invalid error when writing record"}
+ crimson::ct_error::assert_all(
+ "Invalid error when writing record")
);
});
})
dhandler
).handle_error(
replay_ertr::pass_further{},
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"shouldn't meet with any other error other replay_ertr"
- }
+ )
);
}
);
return cjs.read_header(
).handle_error(
open_for_mount_ertr::pass_further{},
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"Invalid error read_header"
- }).safe_then([this, FNAME, delta_handler=std::move(delta_handler)](auto p)
+ )).safe_then([this, FNAME, delta_handler=std::move(delta_handler)](auto p)
mutable {
auto &[head, bl] = *p;
cjs.set_cbj_header(head);
return device_write_bl(target, to_write
).handle_error(
write_ertr::pass_further{},
- crimson::ct_error::assert_all{ "Invalid error" }
+ crimson::ct_error::assert_all( "Invalid error" )
);
}
co_await write_header(
).handle_error(
open_ertr::pass_further{},
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"Invalid error write_header"
- }
+ )
);
co_return get_written_to();
co_await device->writev(offset, bl
).handle_error(
submit_ertr::pass_further{},
- crimson::ct_error::assert_all{ "Invalid error device->write" }
+ crimson::ct_error::assert_all( "Invalid error device->write" )
);
}
co_await device->write(device->get_shard_journal_start(), std::move(bp)
).handle_error(
submit_ertr::pass_further{},
- crimson::ct_error::assert_all{ "Invalid error device->write" }
+ crimson::ct_error::assert_all( "Invalid error device->write" )
);
}
return close_ertr::now();
}).handle_error(
Journal::open_for_mount_ertr::pass_further{},
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"Invalid error write_header"
- }
+ )
);
}
header.alloc_tail = alloc;
return write_header(
).handle_error(
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"encountered invalid error in update_journal_tail"
- });
+ ));
}
void set_initialized(bool init) {
return sm_group.open(new_segment_id
).handle_error(
open_ertr::pass_further{},
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"Invalid error in SegmentAllocator::do_open open"
- }
+ )
).safe_then([this, is_mkfs, FNAME, new_segment_seq](auto sref) {
// initialize new segment
segment_id_t segment_id = sref->get_segment_id();
return sref->write(0, std::move(bl)
).handle_error(
open_ertr::pass_further{},
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"Invalid error in SegmentAllocator::do_open write"
- }
+ )
).safe_then([this,
FNAME,
new_journal_seq,
write_start_offset, std::move(to_write)
).handle_error(
write_ertr::pass_further{},
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"Invalid error in SegmentAllocator::write"
- }
+ )
).finally([cs=current_segment] {});
}
segment_provider.close_segment(seg_to_close->get_segment_id());
}).handle_error(
close_segment_ertr::pass_further{},
- crimson::ct_error::assert_all {
- "Invalid error in SegmentAllocator::close_segment"
- });
+ crimson::ct_error::assert_all(
+ "Invalid error in SegmentAllocator::close_segment"));
}
dhandler
).handle_error(
replay_ertr::pass_further{},
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"shouldn't meet with any other error other replay_ertr"
- }
+ )
);
}
);
).handle_error_interruptible(
update_mapping_iertr::pass_further{},
/* ENOENT in particular should be impossible */
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"Invalid error in BtreeLBAManager::update_mapping"
- }
+ )
);
DEBUGT("laddr={}, paddr {}~0x{:x} => {}~0x{:x}, crc=0x{:x} done -- {}",
t, laddr, prev_addr, prev_len, addr, len, checksum, *cursor);
},
update_mapping_iertr::pass_further{},
/* ENOENT in particular should be impossible */
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"Invalid error in BtreeLBAManager::update_mappings"
- }
+ )
);
});
});
c.trans, ret.src, -1
).handle_error_interruptible(
move_mapping_iertr::pass_further{},
- crimson::ct_error::assert_all{"unexpected error"});
+ crimson::ct_error::assert_all("unexpected error"));
co_await ret.dest->refresh();
auto iter = btree.make_partial_iter(c, *ret.dest);
nullptr
).handle_error_interruptible(
move_mapping_iertr::pass_further{},
- crimson::ct_error::assert_all{"unexpected error"});
+ crimson::ct_error::assert_all("unexpected error"));
assert(cursor->is_indirect());
auto iter = btree.make_partial_iter(c, *cursor);
nullptr
).handle_error_interruptible(
base_iertr::pass_further{},
- crimson::ct_error::assert_all{}
+ crimson::ct_error::assert_all("unexpected error")
);
}
overwrite_mapping
).handle_error_interruptible(
base_iertr::pass_further{},
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"ObjectDataHandler::do_remapping hit invalid error"
- }
+ )
);
assert(!maybe_indirect_extent.is_indirect());
auto extent = ctx.tm.get_mutable_extent(ctx.t, maybe_indirect_extent.extent);
TransactionManager::get_pin_iertr::pass_further{}
).handle_error_interruptible(
ObjectDataHandler::write_iertr::pass_further{},
- crimson::ct_error::assert_all{"unexpected error"}
+ crimson::ct_error::assert_all("unexpected error")
);
assert(extents.size() == 1);
auto &extent = extents.back();
TransactionManager::get_pin_iertr::pass_further{}
).handle_error_interruptible(
ObjectDataHandler::write_iertr::pass_further{},
- crimson::ct_error::assert_all{"unexpected error"}
+ crimson::ct_error::assert_all("unexpected error")
);
}
TransactionManager::get_pin_iertr::pass_further{}
).handle_error_interruptible(
ObjectDataHandler::write_iertr::pass_further{},
- crimson::ct_error::assert_all{"unexpected error"}
+ crimson::ct_error::assert_all("unexpected error")
);
}
TransactionManager::get_pin_iertr::pass_further{}
).handle_error_interruptible(
ObjectDataHandler::write_iertr::pass_further{},
- crimson::ct_error::assert_all{"unexpected error"}
+ crimson::ct_error::assert_all("unexpected error")
);
assert(extents.size() == 1);
auto &extent = extents.back();
return ctx.tm.remove(ctx.t, std::move(edge_mapping));
}).handle_error_interruptible(
base_iertr::pass_further{},
- crimson::ct_error::assert_all{"unexpected error"}
+ crimson::ct_error::assert_all("unexpected error")
);
}
return ctx.tm.remove(ctx.t, std::move(edge_mapping)
).handle_error_interruptible(
base_iertr::pass_further{},
- crimson::ct_error::assert_all{"unexpected error"}
+ crimson::ct_error::assert_all("unexpected error")
);
}
}
return ctx.tm.remove(ctx.t, std::move(mapping));
}).handle_error_interruptible(
base_iertr::pass_further{},
- crimson::ct_error::assert_all{"impossible"}
+ crimson::ct_error::assert_all("impossible")
);
}
data.bl = std::move(bl);
}).handle_error_interruptible(
read_iertr::pass_further{},
- crimson::ct_error::assert_all{"unexpected error"}
+ crimson::ct_error::assert_all("unexpected error")
);
}
if (!begin.is_aligned(block_size)) {
read_paddings, [](auto &fut) { return std::move(fut); }
).handle_error_interruptible(
read_iertr::pass_further{},
- crimson::ct_error::assert_all{"unexpected error"}
+ crimson::ct_error::assert_all("unexpected error")
);
}
dest_mapping = co_await ctx.tm.get_containing_pin(ctx.t, laddr
).handle_error_interruptible(
clone_iertr::pass_further{},
- crimson::ct_error::assert_all{"unexpected enoent"}
+ crimson::ct_error::assert_all("unexpected enoent")
);
}
// For unaligned range cloning, we need to read data.head_padding
ctx.t, begin.get_aligned_laddr(block_size)
).handle_error_interruptible(
clone_iertr::pass_further{},
- crimson::ct_error::assert_all{"unexpected enoent"}
+ crimson::ct_error::assert_all("unexpected enoent")
);
auto d_base = d_object_data.get_reserved_data_base();
auto unaligned_begin = d_base + srcoff;
bufferlist(bl), std::move(pin));
}).handle_error_interruptible(
write_iertr::pass_further{},
- crimson::ct_error::assert_all{"unexpected enoent"}
+ crimson::ct_error::assert_all("unexpected enoent")
);
});
});
std::nullopt, std::move(mapping));
}).handle_error_interruptible(
clear_iertr::pass_further{},
- crimson::ct_error::assert_all{"unexpected enoent"}
+ crimson::ct_error::assert_all("unexpected enoent")
);
}
co_await ctx.tm.read_pins<ObjectDataBlock>(ctx.t, rpins
).handle_error_interruptible(
read_iertr::pass_further{},
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"ObjectDataHandler::read hit invalid error"
- }
+ )
);
for (auto &pin : rpins) {
if (pin.mapping.is_zero_reserved()) {
ctx.t, object_data.get_reserved_data_base()
).handle_error_interruptible(
clone_iertr::pass_further{},
- crimson::ct_error::assert_all{"unexpected enoent"}
+ crimson::ct_error::assert_all("unexpected enoent")
);
co_await do_clone(ctx, object_data, d_object_data, mapping, false);
DEBUGT("{} -> {}",
ctx.t, old_base, old_len, std::move(mapping), {false, true}
).handle_error_interruptible(
clone_iertr::pass_further{},
- crimson::ct_error::assert_all{"unexpected enoent"}
+ crimson::ct_error::assert_all("unexpected enoent")
).discard_result();
auto old_md_start = old_base.with_metadata().with_offset_by_blocks(0);
auto pos = co_await ctx.tm.remove(ctx.t, std::move(*mapping)
).handle_error_interruptible(
clone_iertr::pass_further{},
- crimson::ct_error::assert_all{"unexpected enoent"}
+ crimson::ct_error::assert_all("unexpected enoent")
);
auto base = d_object_data.get_reserved_data_base();
auto len = d_object_data.get_reserved_data_len();
return do_clone(ctx, object_data, d_object_data, std::move(mapping), true);
}).handle_error_interruptible(
clone_iertr::pass_further{},
- crimson::ct_error::assert_all{"unexpected enoent"}
+ crimson::ct_error::assert_all("unexpected enoent")
);
});
}
return seastar::now();
}).handle_error_interruptible(
handle_root_merge_iertr::pass_further{},
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"Invalid error in handle_root_merge"
- }
+ )
);
}
});
}).handle_error_interruptible(
omap_clear_iertr::pass_further{},
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"Invalid error in BtreeOMapManager::omap_clear"
- }
+ )
);
}
dec_ref_ret dec_ref(omap_context_t oc, T&& addr) {
return oc.tm.remove(oc.t, std::forward<T>(addr)).handle_error_interruptible(
dec_ref_iertr::pass_further{},
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"Invalid error in OMapInnerNode helper dec_ref"
- }
+ )
).discard_result();
}
co_return co_await handle_split(oc, child_pt, mresult
).handle_error_interruptible(
rm_key_iertr::pass_further{},
- crimson::ct_error::assert_all{"unexpected error"}
+ crimson::ct_error::assert_all("unexpected error")
);
default:
co_return mresult;
co_return co_await handle_split(oc, child_pt, mresult
).handle_error_interruptible(
rm_key_range_iertr::pass_further{},
- crimson::ct_error::assert_all{"unexpected error"}
+ crimson::ct_error::assert_all("unexpected error")
);
default:
co_return mresult;
}
).handle_error_interruptible(
omap_load_extent_iertr::pass_further{},
- crimson::ct_error::assert_all{ "Invalid error in omap_load_extent" }
+ crimson::ct_error::assert_all( "Invalid error in omap_load_extent" )
).si_then([](auto maybe_indirect_extent) {
assert(!maybe_indirect_extent.is_indirect());
assert(!maybe_indirect_extent.is_clone);
}
).handle_error_interruptible(
log_load_extent_iertr::pass_further{},
- crimson::ct_error::assert_all{ "Invalid error in log_load_extent" }
+ crimson::ct_error::assert_all( "Invalid error in log_load_extent" )
);
assert(!maybe_indirect_extent.is_indirect());
co_await tm.remove(t, mut->get_laddr()
).handle_error_interruptible(
omap_rm_key_iertr::pass_further{},
- crimson::ct_error::assert_all{"Invalid error in remove_node"}
+ crimson::ct_error::assert_all("Invalid error in remove_node")
);
auto mut_prev = tm.get_mutable_extent(t, prev)->template cast<LogNode>();
assert(mut_prev);
co_await tm.remove(t, co_await get_dup_addr_from_root(t, root.addr)
).handle_error_interruptible(
omap_clear_iertr::pass_further{},
- crimson::ct_error::assert_all{"Invalid error in omap_clear"}
+ crimson::ct_error::assert_all("Invalid error in omap_clear")
);
co_await tm.remove(t, root.get_location()
).handle_error_interruptible(
omap_clear_iertr::pass_further{},
- crimson::ct_error::assert_all{"Invalid error in omap_clear"}
+ crimson::ct_error::assert_all("Invalid error in omap_clear")
);
root.update(
L_ADDR_NULL,
return c_other.nm.get_super(c_other.t, tracker_other
).handle_error_interruptible(
eagain_iertr::pass_further{},
- crimson::ct_error::assert_all{"Invalid error during test clone"}
+ 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 c_other.nm.get_super(c_other.t, tracker_other
).handle_error_interruptible(
eagain_iertr::pass_further{},
- crimson::ct_error::assert_all{"Invalid error during test clone"}
+ 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 c.nm.retire_extent(c.t, to_discard
).handle_error_interruptible(
eagain_iertr::pass_further{},
- crimson::ct_error::assert_all(fmt::format(
+ crimson::ct_error::assert_all(
"{} during retire -- to_disgard={}, fresh={}",
- FNAME, to_discard->get_laddr(), fresh_extent->get_laddr()).c_str())
+ FNAME, to_discard->get_laddr(), fresh_extent->get_laddr())
);
}).si_then([this, c] {
boost::ignore_unused(c); // avoid clang warning;
return c.nm.retire_extent(c.t, std::move(extent)
).handle_error_interruptible(
eagain_iertr::pass_further{},
- crimson::ct_error::assert_all(fmt::format(
- "{} addr={}", FNAME, addr).c_str())
+ crimson::ct_error::assert_all("{} addr={}", FNAME, addr)
#ifndef NDEBUG
).si_then([c] {
assert(!c.t.is_conflicted());
return seastar::do_for_each(local_device.mshard_devices, [](auto& mshard_device) {
return mshard_device->do_shard_mount(
).handle_error(
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"Invalid error in NVMeBlockDevice::do_shard_mount"
- });
+ ));
});
});
seastar::open_flags::rw | seastar::open_flags::dsync
).handle_error(
mkfs_ertr::pass_further{},
- crimson::ct_error::assert_all{
- "Invalid error open in RBMDevice::do_primary_mkfs"}
+ crimson::ct_error::assert_all(
+ "Invalid error open in RBMDevice::do_primary_mkfs")
);
co_await initialize_nvme_features();
co_await write_rbm_superblock(
).handle_error(
mkfs_ertr::pass_further{},
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"Invalid error write_rbm_superblock in RBMDevice::do_primary_mkfs"
- });
+ ));
co_await close();
}
seastar::open_flags::rw | seastar::open_flags::dsync
).handle_error(
mkfs_ertr::pass_further{},
- crimson::ct_error::assert_all{
- "Invalid error open in RBMDevice::do_shard_mount"}
+ crimson::ct_error::assert_all(
+ "Invalid error open in RBMDevice::do_shard_mount")
);
auto st = co_await stat_device(
auto s = co_await read_rbm_superblock(RBM_START_ADDRESS
).handle_error(
mount_ertr::pass_further{},
- crimson::ct_error::assert_all{
- "Invalid error read_rbm_superblock in RBMDevice::do_shard_mount"}
+ crimson::ct_error::assert_all(
+ "Invalid error read_rbm_superblock in RBMDevice::do_shard_mount")
);
LOG_PREFIX(RBMDevice::do_shard_mount);
if(seastar::this_shard_id() + seastar::smp::count * store_index >= s.shard_num) {
co_await open(get_device_path(),
seastar::open_flags::rw | seastar::open_flags::dsync
).handle_error(
- crimson::ct_error::assert_all{
- "Invalid error open in RBMDevice::get_shard_nums"}
+ crimson::ct_error::assert_all(
+ "Invalid error open in RBMDevice::get_shard_nums")
);
auto st = co_await stat_device(
).handle_error(
- crimson::ct_error::assert_all{
- "Invalid error stat_device in RBMDevice::get_shard_nums"}
+ crimson::ct_error::assert_all(
+ "Invalid error stat_device in RBMDevice::get_shard_nums")
);
assert(st.block_size > 0);
super.block_size = st.block_size;
auto sb = co_await read_rbm_superblock(RBM_START_ADDRESS
).handle_error(
- crimson::ct_error::assert_all{
- "Invalid error in RBMDevice::get_shard_nums"}
+ crimson::ct_error::assert_all(
+ "Invalid error in RBMDevice::get_shard_nums")
);
co_return sb.shard_num;
INFO("seastore mkfs done");
auto shard_nums = co_await device->get_shard_nums(
).handle_error(
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"Invalid error in device->get_shard_nums"
- });
+ ));
INFO("seastore shard nums {}", shard_nums);
store_shard_nums = shard_nums;
if(crimson::common::get_conf<bool>("seastore_require_partition_count_match_reactor_count")) {
init_managers();
return transaction_manager->mount(
).handle_error(
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"Invalid error in mount_managers"
- });
+ ));
}
seastar::future<> SeaStore::umount()
co_await shard_stores.invoke_on_all([](auto &local_store) {
return seastar::do_for_each(local_store.mshard_stores, [](auto& mshard_store) {
return mshard_store->umount().handle_error(
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"Invalid error in shard_store->umount"
- });
+ ));
});
});
INFO("done");
co_return;
}
co_await shard_stores.local().mshard_stores[0]->mkfs_managers().handle_error(
- crimson::ct_error::assert_all{"Invalid error in SeaStore::mkfs"});
+ crimson::ct_error::assert_all("Invalid error in SeaStore::mkfs"));
co_await prepare_meta(new_osd_fsid);
INFO("done");
}
sds.emplace((device_id_t)id, device_spec_t{magic, dtype, (device_id_t)id});
co_await p_sec_dev->mkfs(
device_config_t::create_secondary(new_osd_fsid, id, dtype, magic)
- ).handle_error(crimson::ct_error::assert_all{"not possible"});
+ ).handle_error(crimson::ct_error::assert_all("not possible"));
co_await set_secondaries();
}
}
co_await shard_stores.invoke_on_all([] (auto &local_store) {
return seastar::do_for_each(local_store.mshard_stores, [](auto& mshard_store) {
return mshard_store->mkfs_managers().handle_error(
- crimson::ct_error::assert_all{"Invalid error in SeaStoreS::mkfs_managers"});
+ crimson::ct_error::assert_all("Invalid error in SeaStoreS::mkfs_managers"));
});
});
co_await prepare_meta(new_osd_fsid);
}).safe_then([&ret] {
return std::move(ret);
}).handle_error(
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"Invalid error in SeaStoreS::list_objects"
- }
+ )
);
}).finally([this] {
assert(shard_stats.pending_read_num);
});
}
).handle_error(
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"Invalid error in SeaStoreS::list_collections"
- }
+ )
).finally([this] {
assert(shard_stats.pending_read_num);
--(shard_stats.pending_read_num);
DEBUG("not exists");
return seastar::make_ready_future<bool>(false);
}),
- crimson::ct_error::assert_all{"unexpected error"}
+ crimson::ct_error::assert_all("unexpected error")
).finally([this] {
assert(shard_stats.pending_read_num);
--(shard_stats.pending_read_num);
crimson::ct_error::enoent::handle([] {
return seastar::make_ready_future<struct stat>();
}),
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"Invalid error in SeaStoreS::stat"
- }
+ )
).finally([this] {
assert(shard_stats.pending_read_num);
--(shard_stats.pending_read_num);
}
return seastar::now();
}),
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"Invalid error in SeaStoreS::do_transaction_step"
- }
+ )
);
}
*ctx.transaction, onode
).handle_error_interruptible(
crimson::ct_error::input_output_error::pass_further(),
- crimson::ct_error::assert_all{
- "Invalid error in SeaStoreS::_rename"});
+ crimson::ct_error::assert_all(
+ "Invalid error in SeaStoreS::_rename"));
}
SeaStore::Shard::tm_ret
);
}).handle_error_interruptible(
tm_iertr::pass_further{},
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"Invalid error in SeaStoreS::_create_collection"
- }
+ )
);
}
co_await collection_manager->update(cmroot, *ctx.transaction, dest_cid, bits)
.handle_error_interruptible(
tm_iertr::pass_further{},
- crimson::ct_error::assert_all{"unexpected error from update in _merge_collection"});
+ crimson::ct_error::assert_all("unexpected error from update in _merge_collection"));
co_await collection_manager->remove(cmroot, *ctx.transaction, cid)
.handle_error_interruptible(
tm_iertr::pass_further{},
- crimson::ct_error::assert_all{"unexpected error from remove in _merge_collection"});
+ crimson::ct_error::assert_all("unexpected error from remove in _merge_collection"));
}
SeaStore::Shard::tm_ret
);
}).handle_error_interruptible(
tm_iertr::pass_further{},
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"Invalid error in SeaStoreS::_create_collection"
- }
+ )
);
}
});
}).handle_error_interruptible(
tm_iertr::pass_further{},
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"Invalid error in SeaStoreS::_create_collection"
- }
+ )
);
}
}).safe_then([FNAME, &key, &value] {
DEBUG("key={} value={} done", key, value);
}).handle_error(
- crimson::ct_error::assert_all{"Invalid error in SeaStore::write_meta"}
+ crimson::ct_error::assert_all("Invalid error in SeaStore::write_meta")
);
});
}
});
});
}).handle_error(
- crimson::ct_error::assert_all{"Invalid error in SeaStoreS::write_meta"}
+ crimson::ct_error::assert_all("Invalid error in SeaStoreS::write_meta")
).finally([this] {
assert(shard_stats.pending_io_num);
--(shard_stats.pending_io_num);
return std::make_tuple(-1, std::string(""));
}
}).handle_error(
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"Invalid error in SeaStore::read_meta"
- }
+ )
);
}
}
}).handle_error_interruptible(
base_iertr::pass_further{},
- crimson::ct_error::assert_all{"unexpected value_too_large"}
+ crimson::ct_error::assert_all("unexpected value_too_large")
);
});
});
}).safe_then([](auto sb) {
return read_ertr::make_ready_future<uint32_t>(sb.shard_num);
}).handle_error(
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"Invalid error in BlockSegmentManager::get_shard_nums"
- }
+ )
);
}
return seastar::do_for_each(local_device.mshard_devices, [](auto& mshard_device) {
return mshard_device->shard_mount(
).handle_error(
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"Invalid error in BlockSegmentManager::mount"
- });
+ ));
});
});
}
return seastar::do_for_each(local_device.mshard_devices, [](auto& mshard_device) {
return mshard_device->shard_mkfs(
).handle_error(
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"Invalid error in BlockSegmentManager::mkfs"
- });
+ ));
});
});
});
}).safe_then([](auto meta){
return read_ertr::make_ready_future<uint32_t>(meta.shard_num);
}).handle_error(
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"Invalid error in ZBDSegmentManager::get_shard_nums"
- });
+ ));
}
ZBDSegmentManager::mount_ret ZBDSegmentManager::mount()
return seastar::do_for_each(local_device.mshard_devices, [](auto& mshard_device) {
return mshard_device->shard_mount(
).handle_error(
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"Invalid error in ZBDSegmentManager::mount"
- });
+ ));
});
});
}
return seastar::do_for_each(local_device.mshard_devices, [](auto& mshard_device) {
return mshard_device->shard_mkfs(
).handle_error(
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"Invalid error in ZBDSegmentManager::mkfs"
- });
+ ));
});
});
});
get_rounded_tail_length()
).handle_error(
read_segment_header_ertr::pass_further{},
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"Invalid error in SegmentManagerGroup::read_segment_tail"
- }
+ )
).safe_then([=, &segment_manager](bufferptr bptr) -> read_segment_tail_ret {
LOG_PREFIX(SegmentManagerGroup::read_segment_tail);
DEBUG("segment {} bptr size 0x{:x}", segment, bptr.length());
get_rounded_header_length()
).handle_error(
read_segment_header_ertr::pass_further{},
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"Invalid error in SegmentManagerGroup::read_segment_header"
- }
+ )
).safe_then([=, &segment_manager](bufferptr bptr) -> read_segment_header_ret {
LOG_PREFIX(SegmentManagerGroup::read_segment_header);
DEBUG("segment {} bptr size 0x{:x}", segment, bptr.length());
INFO("done");
}).handle_error(
mount_ertr::pass_further{},
- crimson::ct_error::assert_all{"unhandled error"}
+ crimson::ct_error::assert_all("unhandled error")
);
}
cache->get_oldest_backref_dirty_from().value_or(start_seq));
}).handle_error(
submit_transaction_iertr::pass_further{},
- crimson::ct_error::assert_all{"Hit error submitting to journal"}
+ crimson::ct_error::assert_all("Hit error submitting to journal")
);
co_await trans_intr::make_interruptible(
t, *extent
).handle_error_interruptible(
rewrite_extent_iertr::pass_further{},
- crimson::ct_error::assert_all{"unexpected enoent"}
+ crimson::ct_error::assert_all("unexpected enoent")
);
co_await lba_manager->update_mapping(
t,
t, *extent
).handle_error_interruptible(
rewrite_extent_iertr::pass_further{},
- crimson::ct_error::assert_all{"unexpected enoent"}
+ crimson::ct_error::assert_all("unexpected enoent")
);
refcount = co_await lba_manager->update_mapping(
t,
*nextent
).handle_error_interruptible(
rewrite_extent_iertr::pass_further{},
- crimson::ct_error::assert_all{"unexpected enoent"}
+ crimson::ct_error::assert_all("unexpected enoent")
);
} else {
ceph_assert(refcount != 0);
mapping.get_extent_type()
).handle_error_interruptible(
clone_iertr::pass_further{},
- crimson::ct_error::assert_all{"unexpected error"}
+ crimson::ct_error::assert_all("unexpected error")
);
assert((dst_base + cloned_to).checked_to_laddr() == r.get_key());
cloned_to += clone_len;
}
}).handle_error_interruptible(
crimson::ct_error::input_output_error::pass_further{},
- crimson::ct_error::assert_all{"unexpected error!"}
+ crimson::ct_error::assert_all("unexpected error!")
);
}
});
}).handle_error_interruptible(
crimson::ct_error::input_output_error::pass_further{},
- crimson::ct_error::assert_all{"unexpected error!"}
+ crimson::ct_error::assert_all("unexpected error!")
);
}
return seastar::now();
}).handle_error_interruptible(
crimson::ct_error::input_output_error::pass_further{},
- crimson::ct_error::assert_all{"unexpected error!"}
+ crimson::ct_error::assert_all("unexpected error!")
);
}
t, std::move(mapping)
).handle_error_interruptible(
remap_mappings_iertr::pass_further{},
- crimson::ct_error::assert_all{"unexpected error"}
+ crimson::ct_error::assert_all("unexpected error")
);
for (auto &remap : remaps) {
auto laddr = (orig_laddr + remap.offset).checked_to_laddr();
type
).handle_error_interruptible(
remap_mappings_iertr::pass_further{},
- crimson::ct_error::assert_all{"unexpected error"}
+ crimson::ct_error::assert_all("unexpected error")
);
ret.emplace_back(new_mapping);
pos = co_await new_mapping.next();
return remove(t, std::move(mapping)
).handle_error_interruptible(
punch_mappings_iertr::pass_further{},
- crimson::ct_error::assert_all{"impossible"}
+ crimson::ct_error::assert_all("impossible")
);
}
}
mapping = co_await remove(t, std::move(mapping)
).handle_error_interruptible(
punch_mappings_iertr::pass_further{},
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"remove_mappings_in_range hit invalid error"
- }
+ )
);
} else {
mapping = co_await _remove_indirect_mapping_only(
t, std::move(mapping)
).handle_error_interruptible(
punch_mappings_iertr::pass_further{},
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"remove_mappings_in_range hit invalid error"
- }
+ )
);
}
}
std::vector<remap_entry_t>(remaps.begin(), remaps.end())
).handle_error_interruptible(
remap_pin_iertr::pass_further{},
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"TransactionManager::remap_pin hit invalid error"
- }
+ )
);
std::vector<LBAMapping> ret;
logger().debug("ECBackend::{} from {}",
"handle_sub_write::reply", reply.from);
return handle_rep_write_reply(std::move(reply));
- }, crimson::ct_error::assert_all{});
+ }, crimson::ct_error::assert_all("unexpected error"));
}
ECBackend::write_iertr::future<>
).si_then([&pg] {
assert(!pg.pgb_is_primary());
return write_iertr::now();
- }, crimson::ct_error::assert_all{});
+ }, crimson::ct_error::assert_all("unexpected error"));
}
ECBackend::write_iertr::future<>
store, coll,
osdmap_oid(e), 0, 0,
CEPH_OSD_OP_FLAG_FADVISE_WILLNEED).handle_error(
- read_errorator::assert_all_func([e](const auto&) {
- ceph_abort_msg(fmt::format("{} read gave enoent on {}",
- __func__, osdmap_oid(e)));
- }));
+ read_errorator::assert_all("{} read gave enoent on {}",
+ __func__, osdmap_oid(e)));
}
read_errorator::future<ceph::bufferlist> OSDMeta::load_inc_map(epoch_t e)
}
return seastar::now();
}).handle_error_interruptible(
- crimson::ct_error::assert_all(fmt::format("{} {} error", *pg, FNAME).c_str())
+ crimson::ct_error::assert_all("{} {} error", std::cref(*pg), FNAME)
);
co_await std::move(resolve_oids);
[ec_backend] (Ref<MOSDECSubOpReadReply> concrete_req) {
return ec_backend->handle_rep_read_reply(
std::move(concrete_req)
- ).handle_error_interruptible(crimson::ct_error::assert_all{});
+ ).handle_error_interruptible(crimson::ct_error::assert_all("unexpected error"));
}}, req);
}, [ref, this](std::exception_ptr) {
logger().debug("{}: ECRepRequest::exception handling", *this);
co_await pg->obc_loader.load_and_lock(
obc_manager, pg->get_lock_type(op_info)
).handle_error_interruptible(
- crimson::ct_error::assert_all(
- fmt::format("{} {} {} error when loading {}",*pg, FNAME, *this, get_target_oid()).c_str())
+ crimson::ct_error::assert_all("{} {} {} error when loading {}",
+ std::cref(*pg), FNAME, std::cref(*this), get_target_oid())
);
auto params = get_do_osd_ops_params();
co_await pg->run_executer(
ox, obc_manager.get_obc(), op_info, osd_ops
).handle_error_interruptible(
- crimson::ct_error::assert_all(
- fmt::format("{} {} {}: got unexpected error {}", *pg, FNAME, *this, get_target_oid()).c_str())
+ crimson::ct_error::assert_all("{} {} {}: got unexpected error {}",
+ std::cref(*pg), FNAME, std::cref(*this), get_target_oid())
);
auto [submitted, completed] = co_await pg->submit_executer(
obc_manager, RWState::RWWRITE
).handle_error_interruptible(
remove_or_update_iertr::pass_further{},
- crimson::ct_error::assert_all{fmt::format(
- "{} error SnapTrimObjSubEvent::snap_trim_obj_subevent_ret_t with {}", *this, coid).c_str()}
+ crimson::ct_error::assert_all(
+ "{} error SnapTrimObjSubEvent::snap_trim_obj_subevent_ret_t with {}",
+ std::cref(*this), coid)
);
logger().debug("{}: got obc={}", *this, obc_manager.get_obc()->get_oid());
t.touch(coll_ref->get_cid(), pgid.make_snapmapper_oid());
}
},
- ::crimson::ct_error::assert_all{fmt::format(
- "{} {} unexpected eio", *this, __func__).c_str()}
+ ::crimson::ct_error::assert_all(
+ "{} {} unexpected eio", std::cref(*this), __func__)
);
}
r->op.from = pg_whoami;
r->set_priority(CEPH_MSG_PRIO_HIGH);
return shard_services.send_to_osd(get_primary().osd, std::move(r), get_osdmap_epoch());
- }).handle_error_interruptible(crimson::ct_error::assert_all{});
+ }).handle_error_interruptible(crimson::ct_error::assert_all("unexpected error"));
}
PG::interruptible_future<> PG::handle_rep_write_reply(Ref<MOSDECSubOpWriteReply> m)
assert(ec_backend);
return ec_backend->handle_rep_write_reply(
std::move(m->op)
- ).handle_error_interruptible(crimson::ct_error::assert_all{});
+ ).handle_error_interruptible(crimson::ct_error::assert_all("unexpected error"));
}
PG::interruptible_future<> PG::handle_rep_read_op(Ref<MOSDECSubOpRead> m)
reply->op = std::move(rep);
return shard_services.send_to_osd(
get_primary().osd, std::move(reply), get_osdmap_epoch());
- }).handle_error_interruptible(crimson::ct_error::assert_all{});
+ }).handle_error_interruptible(crimson::ct_error::assert_all("unexpected error"));
}
PG::interruptible_future<> PG::do_update_log_missing(
);
}),
rollback_ertr::pass_further{},
- crimson::ct_error::assert_all{"unexpected error in rollback"}
+ crimson::ct_error::assert_all("unexpected error in rollback")
);
}
return seastar::make_ready_future<bufferlist>();
}),
PGBackend::write_iertr::pass_further{},
- crimson::ct_error::assert_all{fmt::format(
- "read error in mutate_object_contents of {}", os.oi.soid).c_str()
- }).si_then([this, &os, &osd_op, &txn,
+ crimson::ct_error::assert_all(
+ "read error in mutate_object_contents of {}", os.oi.soid)).si_then([this, &os, &osd_op, &txn,
&delta_stats, &osd_op_params]
(auto &&bl) mutable -> PGBackend::tmapup_iertr::future<> {
auto result = crimson::common::do_tmap_up(
return seastar::make_ready_future<epoch_t>(*epoch);
}
},
- FuturizedStore::Shard::read_errorator::assert_all{
+ FuturizedStore::Shard::read_errorator::assert_all(
"PGMeta::get_epoch: unable to read pgmeta"
- });
+ ));
});
}
return seastar::make_ready_future<std::tuple<pg_info_t, PastIntervals>>(
std::make_tuple(std::move(info), std::move(past_intervals)));
},
- FuturizedStore::Shard::read_errorator::assert_all{
+ FuturizedStore::Shard::read_errorator::assert_all(
"PGMeta::load: unable to read pgmeta"
- });
+ ));
}
crimson::ct_error::enoent::handle([](auto) {
return false;
}),
- crimson::ct_error::assert_all(fmt::format("{} {} error when loading obc", pg, FNAME).c_str())
+ crimson::ct_error::assert_all("{} {} error when loading obc",
+ std::cref(pg), FNAME)
);
if (!found) {
// if the object does not exist here, it must have been removed
crimson::ct_error::enoent::handle([](auto) {
return false;
}),
- crimson::ct_error::assert_all(fmt::format("{} {} error when loading obc", pg, FNAME).c_str())
+ crimson::ct_error::assert_all("{} {} error when loading obc",
+ std::cref(pg), FNAME)
);
if (!found) {
// if the object does not exist here, it must have been removed
});
});
}).handle_error_interruptible(
- crimson::ct_error::assert_all(fmt::format(
- "{} {} error with {} need {} ", pg, FNAME, soid, need).c_str())
+ crimson::ct_error::assert_all("{} {} error with {} need {}",
+ std::cref(pg), FNAME, soid, need)
);
}
new_progress.omap_complete = false;
}
}).handle_error(
- crimson::os::FuturizedStore::Shard::read_errorator::assert_all(fmt::format(
- "{} ReplicatedRecoveryBackend::read_omap_for_push_op error with {}", pg, oid).c_str())
+ crimson::os::FuturizedStore::Shard::read_errorator::assert_all(
+ "{} ReplicatedRecoveryBackend::read_omap_for_push_op error with {}",
+ std::cref(pg), oid)
)
);
}
).safe_then([] (auto ret) {
ceph_assert (ret == ObjectStore::omap_iter_ret_t::NEXT);
}).handle_error(
- crimson::os::FuturizedStore::Shard::read_errorator::assert_all{}
+ crimson::os::FuturizedStore::Shard::read_errorator::assert_all("unexpected error")
);
});
}
to_get.insert(key);
auto&& vals = co_await store->get_sharded_store().omap_get_values(
coll, oid, to_get).handle_error(
- crimson::os::FuturizedStore::Shard::read_errorator::assert_all{}
+ crimson::os::FuturizedStore::Shard::read_errorator::assert_all("unexpected error")
);
auto it = vals.find(key);
if (it != vals.end()) {
bl.append_zero(size);
return seastar::make_ready_future<bufferlist>(std::move(bl));
}),
- crimson::ct_error::assert_all{"Unrecoverable error in FSDriver::read"}
+ crimson::ct_error::assert_all("Unrecoverable error in FSDriver::read")
).then([size](auto &&bl) {
if (bl.length() < size) {
bl.append_zero(size - bl.length());
});
});
}).handle_error(
- crimson::ct_error::assert_all{"store-nbd write"}
+ crimson::ct_error::assert_all("store-nbd write")
);
}
});
});
}).handle_error(
- crimson::ct_error::assert_all{"store-nbd read"}
+ crimson::ct_error::assert_all("store-nbd read")
).then([blptrret=std::move(blptrret)]() mutable {
logger().debug("read complete");
return std::move(*blptrret);
logger().debug("mkfs complete");
return TransactionManager::mkfs_ertr::now();
}).handle_error(
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"Invalid errror during TMDriver::mkfs"
- }
+ )
);
}
init();
return tm->mount();
}).handle_error(
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"Invalid errror during TMDriver::mount"
- }
+ )
);
};
clear();
return device->close();
}).handle_error(
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"Invalid errror during TMDriver::close"
- }
+ )
);
}
).safe_then([] (auto ret) {
ceph_assert (ret == ObjectStore::omap_iter_ret_t::NEXT);
}).handle_error(
- crimson::os::FuturizedStore::Shard::read_errorator::assert_all{}
+ crimson::os::FuturizedStore::Shard::read_errorator::assert_all("unexpected error")
);
for (auto &p : kvs) {
});
});
}).handle_error(
- crimson::ct_error::assert_all{"Invalid error in _mkfs"}
+ crimson::ct_error::assert_all("Invalid error in _mkfs")
);
}
new UnboundedBtree(NodeExtentManager::create_dummy(IS_DUMMY_SYNC))
);
return INTR(tree->mkfs, *ref_t).handle_error(
- crimson::ct_error::assert_all{"Unable to mkfs"}
+ crimson::ct_error::assert_all("Unable to mkfs")
);
}
return c.nm.get_super(c.t, root_tracker
).handle_error_interruptible(
eagain_iertr::pass_further{},
- crimson::ct_error::assert_all{"Invalid error during create_initial()"}
+ crimson::ct_error::assert_all("Invalid error during create_initial()")
).si_then([c, initial](auto super) {
initial->make_root_new(c, std::move(super));
laddr_hint_t hint;
submit_result.write_result.start_seq);
complete_commit(t);
}
- ).handle_error(crimson::ct_error::assert_all{});
+ ).handle_error(crimson::ct_error::assert_all("unexpected error"));
});
}
});
});
}).handle_error(
- crimson::ct_error::assert_all{"error"}
+ crimson::ct_error::assert_all("error")
);
}
epm.reset();
cache.reset();
}).handle_error(
- crimson::ct_error::assert_all{"Unable to close"}
+ crimson::ct_error::assert_all("Unable to close")
);
}
};
});
}
seastar::future<> close() {
- return cbj->close().handle_error(crimson::ct_error::assert_all{});
+ return cbj->close().handle_error(crimson::ct_error::assert_all("unexpected error"));
}
auto get_records_available_size() {
return cbj->get_cjs().get_records_available_size();
return replay();
});
});
- }).handle_error(crimson::ct_error::assert_all{});
+ }).handle_error(crimson::ct_error::assert_all("unexpected error"));
}
};
size = device->get_available_size();
rbm_manager.reset(new BlockRBManager(device.get(), std::string(), false));
config = get_rbm_ephemeral_device_config(0, 1);
- return device->mkfs(config).handle_error(crimson::ct_error::assert_all{}
+ return device->mkfs(config).handle_error(crimson::ct_error::assert_all("unexpected error")
).then([this] {
- return device->mount().handle_error(crimson::ct_error::assert_all{}
+ return device->mount().handle_error(crimson::ct_error::assert_all("unexpected error")
).then([this] {
- return rbm_manager->open().handle_error(crimson::ct_error::assert_all{});
+ return rbm_manager->open().handle_error(crimson::ct_error::assert_all("unexpected error"));
});
});
}
seastar::future<> tear_down_fut() final {
co_await rbm_manager->close().handle_error(
- crimson::ct_error::assert_all{});
+ crimson::ct_error::assert_all("unexpected error"));
co_await device->close().handle_error(
- crimson::ct_error::assert_all{});
+ crimson::ct_error::assert_all("unexpected error"));
rbm_manager.reset();
device.reset();
co_return;
SeaStoreShard &sharded_seastore) {
return sharded_seastore.get_attrs(coll, oid)
.handle_error(
- SeaStoreShard::get_attrs_ertr::assert_all{"unexpected error"})
+ SeaStoreShard::get_attrs_ertr::assert_all("unexpected error"))
.get();
}
std::string_view name) {
return sharded_seastore.get_attr(coll, oid, name)
.handle_error(
- SeaStoreShard::get_attr_errorator::assert_all{"unexpected error"})
+ SeaStoreShard::get_attr_errorator::assert_all("unexpected error"))
.get();
}
cache->complete_commit(*t, prev, seq /* TODO */);
return prev;
},
- crimson::ct_error::assert_all{"failed to submit"}
+ crimson::ct_error::assert_all("failed to submit")
);
}
});
});
}).handle_error(
- crimson::ct_error::assert_all{"failed to submit"}
+ crimson::ct_error::assert_all("failed to submit")
);
}
epm.reset();
cache.reset();
}).handle_error(
- Cache::close_ertr::assert_all{}
+ Cache::close_ertr::assert_all("unexpected error")
);
}
};
}).safe_then([this](auto) {
dummy_tail = journal_seq_t{0,
paddr_t::make_seg_paddr(segment_id_t(segment_manager->get_device_id(), 0), 0)};
- }, crimson::ct_error::assert_all{"Unable to mount"});
+ }, crimson::ct_error::assert_all("Unable to mount"));
}
seastar::future<> tear_down_fut() final {
sms.reset();
journal.reset();
}).handle_error(
- crimson::ct_error::assert_all{"Unable to close"}
+ crimson::ct_error::assert_all("Unable to close")
);
}
[](const crimson::ct_error::eagain &e) {
return seastar::make_ready_future<TestBlockRef>();
},
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"get_extent got invalid error"
- }
+ )
).get();
if (t.t->is_conflicted()) {
return nullptr;
[](const crimson::ct_error::eagain &e) {
return seastar::make_ready_future<TestBlockRef>();
},
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"get_extent got invalid error"
- }
+ )
).get();
if (t.t->is_conflicted()) {
return nullptr;
[](const crimson::ct_error::eagain &e) {
return seastar::make_ready_future<TestBlockRef>();
},
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"read_pin got invalid error"
- }
+ )
).get();
if (ext) {
if (indirect) {
[](const crimson::ct_error::eagain &e) {
return seastar::make_ready_future<std::optional<LBAMapping>>();
},
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"get_extent got invalid error"
- }
+ )
).get();
if (pin) {
EXPECT_EQ(offset, pin->get_key());
[](const crimson::ct_error::eagain &e) {
return seastar::make_ready_future<bool>(false);
},
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"try_submit_transaction hit invalid error"
- }
+ )
).then([this](auto ret) {
return epm->run_background_work_until_halt(
).then([ret] { return ret; });
return epm->background_process.trimmer->trim();
}
}).handle_error(
- crimson::ct_error::assert_all{
+ crimson::ct_error::assert_all(
"Invalid error in SeaStore::list_collections"
- }
+ )
);
}
});
});
}).handle_error(
- crimson::ct_error::assert_all{}
+ crimson::ct_error::assert_all("unexpected error")
);
}
seastar::future<> setup() final {
rb_device = random_block_device::create_test_ephemeral();
device_config_t config = get_rbm_ephemeral_device_config(0, 1);
- return rb_device->mkfs(config).handle_error(crimson::ct_error::assert_all{});
+ return rb_device->mkfs(config).handle_error(crimson::ct_error::assert_all("unexpected error"));
}
void remount() final {}
return teardown().then([this] {
devices->remount();
return _init().then([this] {
- return _mount().handle_error(crimson::ct_error::assert_all{});
+ return _mount().handle_error(crimson::ct_error::assert_all("unexpected error"));
});
}).then([FNAME] {
SUBINFO(test, "finish");
).safe_then([this] {
return restart_fut();
}).handle_error(
- crimson::ct_error::assert_all{}
+ crimson::ct_error::assert_all("unexpected error")
).then([FNAME] {
SUBINFO(test, "finish");
});
virtual seastar::future<> _teardown() {
return tm->close().handle_error(
- crimson::ct_error::assert_all{"Error in teardown"}
+ crimson::ct_error::assert_all("Error in teardown")
);
}
virtual FuturizedStore::mount_ertr::future<> _mount() {
return tm->mount(
).handle_error(
- crimson::ct_error::assert_all{"Error in mount"}
+ crimson::ct_error::assert_all("Error in mount")
).then([this] {
return epm->stop_background();
}).then([this] {
virtual FuturizedStore::mkfs_ertr::future<> _mkfs() {
return tm->mkfs(
).handle_error(
- crimson::ct_error::assert_all{"Error in mkfs"}
+ crimson::ct_error::assert_all("Error in mkfs")
);
}
return server.msgr->bind(entity_addrvec_t{addr}
).safe_then([&server] {
return server.msgr->start({&server.dispatcher});
- }, crimson::net::Messenger::bind_ertr::assert_all{"bind failed"}
+ }, crimson::net::Messenger::bind_ertr::assert_all("bind failed")
).then([&dispatcher=server.dispatcher, count] {
return dispatcher.on_reply.wait([&dispatcher, count] {
return dispatcher.count >= count;
1
).handle_error_interruptible(
base_iertr::pass_further{},
- ct_error::assert_all{"crash on eio"}
+ ct_error::assert_all("crash on eio")
).si_then([](auto) {
return base_iertr::now();
});
projects / ceph.git / commitdiff