ceph_abort doesn't print a message. Use ceph_abort_msg instead.
Most of the instances are not printing useful information but some are:
ceph_abort_msg("seastore device size setting is too small");
```
::ceph::__ceph_abort( __FILE__, __LINE__, __CEPH_ASSERT_FUNCTION, "abort() called")
::ceph::__ceph_abort( __FILE__, __LINE__, __CEPH_ASSERT_FUNCTION, msg)
```
Signed-off-by: Matan Breizman <mbreizma@redhat.com>
// and abort after putting entire data field on wire. This will be used by
// the kernel client to avoid unnecessary buffering.
if (!ok) {
- ceph_abort("TODO");
+ ceph_abort_msg("TODO");
}
return &rx_segments_data;
});
return seastar::sleep_abortable(
std::chrono::seconds(10), *p_unblocked
).then([] {
- ceph_abort("Timeout (10s) in socket_blocker::block()");
+ ceph_abort_msg("Timeout (10s) in socket_blocker::block()");
}).handle_exception_type([] (const seastar::sleep_aborted& e) {
// wait done!
});
logger().info("[Test] got BLOCK");
return conn.interceptor->blocker.block();
default:
- ceph_abort("unexpected action from trap");
+ ceph_abort_msg("unexpected action from trap");
return seastar::now();
}
});;
return seastar::now();
}
default: {
- ceph_abort("impossible next step");
+ ceph_abort_msg("impossible next step");
}
}
}).handle_exception([this](std::exception_ptr eptr) {
execute_server_wait();
break;
default:
- ceph_abort("impossible next step");
+ ceph_abort_msg("impossible next step");
}
}).handle_exception([this](std::exception_ptr eptr) {
const char *e_what;
trap = action;
break;
default:
- ceph_abort("unexpected action from trap");
+ ceph_abort_msg("unexpected action from trap");
}
return seastar::make_ready_future<>();
}
force_shutdown();
return blocker->block();
default:
- ceph_abort("unexpected action from trap");
+ ceph_abort_msg("unexpected action from trap");
}
return seastar::make_ready_future<>();
}
ctx.exit_out_dispatching("switched", conn);
return seastar::make_ready_future<stop_t>(stop_t::yes);
default:
- ceph_abort("impossible");
+ ceph_abort_msg("impossible");
}
}).handle_exception_type([this, &ctx](const std::system_error& e) {
auto io_state = ctx.get_io_state();
return seastar::now();
}
// TODO: message throttler
- ceph_abort("TODO");
+ ceph_abort_msg("TODO");
return seastar::now();
}).then([this, msg_size] {
// throttle_bytes() logic
crimson::get_logger(ceph_subsys_ms).error(
"{} try_enter_out_dispatching() got wrong io_state {}",
conn, io_state);
- ceph_abort("impossible");
+ ceph_abort_msg("impossible");
}
}
ERROR("out of space with {} {} {} {}",
type, segment_seq_printer_t{seq}, category,
rewrite_gen_printer_t{generation});
- ceph_abort("seastore device size setting is too small");
+ ceph_abort_msg("seastore device size setting is too small");
return NULL_SEG_ID;
}
} else {
ceph_assert(get_segments_reclaimable() == 0);
// see should_clean_space()
- ceph_abort("impossible!");
+ ceph_abort_msg("impossible!");
return NULL_SEG_ID;
}
}
t, addr, len, key,
pos.get_key(), pos.get_val().len,
pos.get_val());
- ceph_abort("not possible for the backref tree");
+ ceph_abort_msg("not possible for the backref tree");
return BackrefBtree::iterate_repeat_ret_inner(
interruptible::ready_future_marker{},
seastar::stop_iteration::no);
}
} else {
ceph_assert(!child_node->is_valid());
- ceph_abort("impossible");
+ ceph_abort_msg("impossible");
}
} else if (ret == Transaction::get_extent_ret::ABSENT) {
BaseChildNode<std::remove_reference_t<decltype(*node)>,
i->get_key())));
}
} else {
- ceph_abort("impossible");
+ ceph_abort_msg("impossible");
}
}
}
if (!i.ref->is_valid()) {
SUBERRORT(seastore_t,
"read_set got invalid extent, aborting -- {}", t, *i.ref);
- ceph_abort("no invalid extent allowed in transactions' read_set");
+ ceph_abort_msg("no invalid extent allowed in transactions' read_set");
}
get_by_ext(efforts.read_by_ext,
i.ref->get_type()).increment(i.ref->get_length());
remove_backref_extent(extent->get_paddr());
} else {
ERRORT("Got unexpected extent type: {}", t, *extent);
- ceph_abort("imposible");
+ ceph_abort_msg("imposible");
}
}
alloc_deltas.emplace_back(std::move(rel_delta));
SUBINFOT(seastore_t, "alloc_tail all trimmed, set to head {}, src={}",
t, alloc_tail, trans_src);
} else if (*maybe_alloc_tail == JOURNAL_SEQ_NULL) {
- ceph_abort("impossible");
+ ceph_abort_msg("impossible");
} else {
alloc_tail = *maybe_alloc_tail;
}
i->get_type());
} else {
ERRORT("{}", t, *i);
- ceph_abort("not possible");
+ ceph_abort_msg("not possible");
}
});
if (result == Transaction::get_extent_ret::RETIRED) {
SUBERRORT(seastore_cache, "{} {}~0x{:x} is retired on t -- {}",
t, T::TYPE, offset, length, *ret);
- ceph_abort("impossible");
+ ceph_abort_msg("impossible");
} else if (result == Transaction::get_extent_ret::PRESENT) {
assert(ret->get_length() == length);
if (ret->is_fully_loaded()) {
if (status == Transaction::get_extent_ret::RETIRED) {
SUBERRORT(seastore_cache, "{} {}~0x{:x} {} is retired on t -- {}",
t, type, offset, length, laddr, *ret);
- ceph_abort("impossible");
+ ceph_abort_msg("impossible");
} else if (status == Transaction::get_extent_ret::PRESENT) {
assert(ret->get_length() == length);
if (ret->is_fully_loaded()) {
: CachedExtent(CachedExtent::retired_placeholder_construct_t{}, length) {}
CachedExtentRef duplicate_for_write(Transaction&) final {
- ceph_abort("Should never happen for a placeholder");
+ ceph_abort_msg("Should never happen for a placeholder");
return CachedExtentRef();
}
ceph::bufferlist get_delta() final {
- ceph_abort("Should never happen for a placeholder");
+ ceph_abort_msg("Should never happen for a placeholder");
return ceph::bufferlist();
}
void apply_delta_and_adjust_crc(
paddr_t base, const ceph::bufferlist &bl) final {
- ceph_abort("Should never happen for a placeholder");
+ ceph_abort_msg("Should never happen for a placeholder");
}
void on_rewrite(Transaction &, CachedExtent&, extent_len_t) final {}
}
void on_delta_write(paddr_t record_block_offset) final {
- ceph_abort("Should never happen for a placeholder");
+ ceph_abort_msg("Should never happen for a placeholder");
}
};
extent_len_t len;
};
virtual std::optional<modified_region_t> get_modified_region() {
- ceph_abort("Unsupported");
+ ceph_abort_msg("Unsupported");
return std::nullopt;
}
virtual void clear_modified_region() {
- ceph_abort("Unsupported");
+ ceph_abort_msg("Unsupported");
}
virtual ~LogicalCachedExtent() {}
}
if (!proceed_clean_main && !proceed_clean_cold) {
- ceph_abort("no background process will start");
+ ceph_abort_msg("no background process will start");
}
return seastar::when_all(
[this, FNAME, proceed_clean_main,
}
break;
default:
- ceph_abort("impossible");
+ ceph_abort_msg("impossible");
}
return ret;
}
assert(get_written_to().segment_seq != NULL_SEG_SEQ);
auto encoded_size = to_write.length();
if (encoded_size > get_records_available_size()) {
- ceph_abort("should be impossible with EPM reservation");
+ ceph_abort_msg("should be impossible with EPM reservation");
}
assert(encoded_size + get_rbm_addr(get_written_to())
< get_journal_end());
} else if (num_outstanding_io == io_depth_limit) {
state = state_t::FULL;
} else {
- ceph_abort("fatal error: io-depth overflow");
+ ceph_abort_msg("fatal error: io-depth overflow");
}
}
return ObjectDataHandler::write_iertr::now();
});
} else {
- ceph_abort("impossible");
+ ceph_abort_msg("impossible");
return ObjectDataHandler::write_iertr::now();
}
});
ObjectDataHandler::write_iertr::pass_further{}
);
} else {
- ceph_abort("impossible");
+ ceph_abort_msg("impossible");
return ObjectDataHandler::write_iertr::now();
}
});
}
} else {
assert(is_invalid());
- ceph_abort("impossible");
+ ceph_abort_msg("impossible");
}
#endif
}
p_node_base = current_p_node_base;
} else {
// It is impossible to change state backwards, see node_types.h.
- ceph_abort("impossible");
+ ceph_abort_msg("impossible");
}
}
ERRORT("load addr={}, is_level_tail={} error, "
"got invalid header -- {}",
c.t, addr, expect_is_level_tail, fmt::ptr(extent));
- ceph_abort("fatal error");
+ ceph_abort_msg("fatal error");
}
if (header.get_is_level_tail() != expect_is_level_tail) {
ERRORT("load addr={}, is_level_tail={} error, "
"is_level_tail mismatch -- {}",
c.t, addr, expect_is_level_tail, fmt::ptr(extent));
- ceph_abort("fatal error");
+ ceph_abort_msg("fatal error");
}
auto node_type = header.get_node_type();
ERRORT("load addr={}, is_level_tail={} error, "
"leaf length mismatch -- {}",
c.t, addr, expect_is_level_tail, fmt::ptr(extent));
- ceph_abort("fatal error");
+ ceph_abort_msg("fatal error");
}
auto impl = LeafNodeImpl::load(extent, *field_type);
auto *derived_ptr = impl.get();
ERRORT("load addr={}, is_level_tail={} error, "
"internal length mismatch -- {}",
c.t, addr, expect_is_level_tail, fmt::ptr(extent));
- ceph_abort("fatal error");
+ ceph_abort_msg("fatal error");
}
auto impl = InternalNodeImpl::load(extent, *field_type);
auto *derived_ptr = impl.get();
return eagain_iertr::make_ready_future<Ref<Node>>(
new InternalNode(derived_ptr, std::move(impl)));
} else {
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
});
}
//
// In order to preserve the invariant, we need to make sure the new
// internal root also has at least 2 children.
- ceph_abort("trying to erase the last item from the internal root node");
+ ceph_abort_msg("trying to erase the last item from the internal root node");
}
// track erase
if (child->level() + 1 != level()) {
ERRORT("loaded child {} error from parent {} at pos({}), level mismatch",
c.t, child->get_name(), get_name(), position);
- ceph_abort("fatal error");
+ ceph_abort_msg("fatal error");
}
child->as_child(position, this);
return child;
eagain_ifuture<> LeafNode::extend_value(
context_t c, const search_position_t& pos, value_size_t extend_size)
{
- ceph_abort("not implemented");
+ ceph_abort_msg("not implemented");
return eagain_iertr::now();
}
eagain_ifuture<> LeafNode::trim_value(
context_t c, const search_position_t& pos, value_size_t trim_size)
{
- ceph_abort("not implemented");
+ ceph_abort_msg("not implemented");
return eagain_iertr::now();
}
// good
} else {
assert(p_cursor->is_invalid());
- ceph_abort("impossible");
+ ceph_abort_msg("impossible");
}
}
#endif
protected:
virtual eagain_ifuture<> test_clone_non_root(context_t, Ref<InternalNode>) const {
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
virtual eagain_ifuture<search_result_t> lower_bound_tracked(
context_t, const key_hobj_t&, MatchHistory&) = 0;
SUBERROR(seastore_onode,
"got unknown op {} when replay {}",
op, node);
- ceph_abort("fatal error");
+ ceph_abort_msg("fatal error");
}
} catch (buffer::error& e) {
SUBERROR(seastore_onode,
"got decode error {} when replay {}",
e.what(), node);
- ceph_abort("fatal error");
+ ceph_abort_msg("fatal error");
}
}
// NODE_TYPE == node_type_t::LEAF
value.encode(encoded);
} else {
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
}
// NODE_TYPE == node_type_t::LEAF
return value_config_t::decode(delta);
} else {
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
}
recorder = nullptr;
} else {
// extent is invalid or retired
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
#ifndef NDEBUG
auto ref_recorder = recorder_t::create_for_replay();
protected:
NodeExtentRef mutate(context_t, DeltaRecorderURef&&) override {
- ceph_abort("impossible path"); }
+ ceph_abort_msg("impossible path"); }
DeltaRecorder* get_recorder() const override {
return nullptr; }
CachedExtentRef duplicate_for_write(Transaction&) override {
- ceph_abort("impossible path"); }
+ ceph_abort_msg("impossible path"); }
extent_types_t get_type() const override {
return extent_types_t::TEST_BLOCK; }
ceph::bufferlist get_delta() override {
- ceph_abort("impossible path"); }
+ ceph_abort_msg("impossible path"); }
void apply_delta(const ceph::bufferlist&) override {
- ceph_abort("impossible path"); }
+ ceph_abort_msg("impossible path"); }
};
template <bool SYNC>
} else if (field_type == field_type_t::N3) {
return DeltaRecorderT<leaf_fields_3_t, node_type_t::LEAF>::create_for_replay();
} else {
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
} else if (node_type == node_type_t::INTERNAL) {
if (field_type == field_type_t::N0) {
} else if (field_type == field_type_t::N3) {
return DeltaRecorderT<internal_fields_3_t, node_type_t::INTERNAL>::create_for_replay();
} else {
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
} else {
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
}
auto field_type = header.get_field_type();
if (!field_type.has_value()) {
ERROR("replay got invalid node -- {}", *this);
- ceph_abort("fatal error");
+ ceph_abort_msg("fatal error");
}
auto node_type = header.get_node_type();
recorder = create_replay_recorder(node_type, *field_type);
SUBERRORT(seastore_onode,
"allocated {}B but got invalid extent: {}",
t, len, *extent);
- ceph_abort("fatal error");
+ ceph_abort_msg("fatal error");
}
assert(extent->get_length() == len);
std::ignore = len;
protected:
NodeExtentRef mutate(context_t, DeltaRecorderURef&&) override {
- ceph_abort("impossible path"); }
+ ceph_abort_msg("impossible path"); }
DeltaRecorder* get_recorder() const override {
- ceph_abort("impossible path"); }
+ ceph_abort_msg("impossible path"); }
CachedExtentRef duplicate_for_write(Transaction&) override {
- ceph_abort("impossible path"); }
+ ceph_abort_msg("impossible path"); }
extent_types_t get_type() const override {
return extent_types_t::TEST_BLOCK; }
ceph::bufferlist get_delta() override {
- ceph_abort("impossible path"); }
+ ceph_abort_msg("impossible path"); }
void apply_delta(const ceph::bufferlist&) override {
- ceph_abort("impossible path"); }
+ ceph_abort_msg("impossible path"); }
private:
TestReplayExtent(ceph::bufferptr&& ptr, DeltaRecorderURef&& recorder)
} else if (type == field_type_t::N3) {
return InternalNode3::allocate(c, hint, is_level_tail, level);
} else {
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
}
} else if (type == field_type_t::N3) {
return LeafNode3::allocate(c, hint, is_level_tail, 0);
} else {
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
}
} else if (type == field_type_t::N3) {
return InternalNode3::load(extent);
} else {
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
}
} else if (type == field_type_t::N3) {
return LeafNode3::load(extent);
} else {
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
}
virtual void get_slot(const search_position_t&, // IN
key_view_t* = nullptr, // OUT
const laddr_packed_t** = nullptr) const { // OUT
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
#pragma GCC diagnostic ignored "-Woverloaded-virtual"
virtual void get_prev_slot(search_position_t&, // IN&OUT
key_view_t* = nullptr, // OUT
const laddr_packed_t** = nullptr) const { // OUT
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
#pragma GCC diagnostic ignored "-Woverloaded-virtual"
virtual void get_next_slot(search_position_t&, // IN&OUT
key_view_t* = nullptr, // OUT
const laddr_packed_t** = nullptr) const { // OUT
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
#pragma GCC diagnostic ignored "-Woverloaded-virtual"
virtual void get_largest_slot(search_position_t* = nullptr, // OUT
key_view_t* = nullptr, // OUT
const laddr_packed_t** = nullptr) const { // OUT
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
#pragma GCC diagnostic ignored "-Woverloaded-virtual"
virtual lookup_result_t<node_type_t::INTERNAL> lower_bound(
const key_hobj_t&, MatchHistory&,
key_view_t* = nullptr, internal_marker_t = {}) const {
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
#pragma GCC diagnostic ignored "-Woverloaded-virtual"
virtual const laddr_packed_t* insert(
const key_view_t&, const laddr_t&, search_position_t&, match_stage_t&, node_offset_t&) {
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
#pragma GCC diagnostic ignored "-Woverloaded-virtual"
virtual std::tuple<search_position_t, bool, const laddr_packed_t*> split_insert(
NodeExtentMutable&, NodeImpl&, const key_view_t&, const laddr_t&,
search_position_t&, match_stage_t&, node_offset_t&) {
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
virtual const laddr_packed_t* get_tail_value() const = 0;
virtual void get_slot(const search_position_t&, // IN
key_view_t* = nullptr, // OUT
const value_header_t** = nullptr) const { // OUT
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
#pragma GCC diagnostic ignored "-Woverloaded-virtual"
virtual void get_prev_slot(search_position_t&, // IN&OUT
key_view_t* = nullptr, // OUT
const value_header_t** = nullptr) const { // OUT
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
#pragma GCC diagnostic ignored "-Woverloaded-virtual"
virtual void get_next_slot(search_position_t&, // IN&OUT
key_view_t* = nullptr, // OUT
const value_header_t** = nullptr) const { // OUT
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
#pragma GCC diagnostic ignored "-Woverloaded-virtual"
virtual void get_largest_slot(search_position_t* = nullptr, // OUT
key_view_t* = nullptr, // OUT
const value_header_t** = nullptr) const { // OUT
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
#pragma GCC diagnostic ignored "-Woverloaded-virtual"
virtual lookup_result_t<node_type_t::LEAF> lower_bound(
const key_hobj_t&, MatchHistory&,
key_view_t* = nullptr, leaf_marker_t = {}) const {
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
#pragma GCC diagnostic ignored "-Woverloaded-virtual"
virtual const value_header_t* insert(
const key_hobj_t&, const value_config_t&, search_position_t&, match_stage_t&, node_offset_t&) {
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
#pragma GCC diagnostic ignored "-Woverloaded-virtual"
virtual std::tuple<search_position_t, bool, const value_header_t*> split_insert(
NodeExtentMutable&, NodeImpl&, const key_hobj_t&, const value_config_t&,
search_position_t&, match_stage_t&, node_offset_t&) {
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
virtual std::tuple<match_stage_t, node_offset_t> evaluate_insert(
merge_stage = STAGE;
size_comp = right_node_stage.header_size();
} else {
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
} else {
key_view_t left_pivot_index;
auto p_write = left_node_stage.get_end_p_laddr();
mut.copy_in_absolute((void*)p_write, tail_value);
} else {
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
} else {
typename stage_t::template StagedAppender<KeyT::VIEW> left_appender;
stage_t::template get_slot<true, false>(
extent.read(), cast_down<STAGE>(pos), p_index_key, nullptr);
} else {
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
#ifndef NDEBUG
if (pp_value) {
stage_t::template get_prev_slot<false, true>(
extent.read(), _pos, nullptr, pp_value);
} else {
- ceph_abort("not implemented");
+ ceph_abort_msg("not implemented");
}
#ifndef NDEBUG
auto _nxt_pos = _pos;
find_next = stage_t::template get_next_slot<false, true>(
extent.read(), cast_down<STAGE>(pos), nullptr, pp_value);
} else {
- ceph_abort("not implemented");
+ ceph_abort_msg("not implemented");
}
if (find_next) {
pos = search_position_t::end();
stage_t::template get_largest_slot<true, false, false>(
extent.read(), &cast_down_fill_0<STAGE>(*p_pos), nullptr, nullptr);
} else {
- ceph_abort("not implemented");
+ ceph_abort_msg("not implemented");
}
}
assert(is_level_tail());
return extent.read().get_end_p_laddr();
} else {
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
}
assert(p_value->value == src);
extent.update_child_addr_replayable(dst, const_cast<laddr_packed_t*>(p_value));
} else {
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
}
}
return {insert_stage, insert_size};
} else {
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
}
key, value, history, mstat, cast_down<STAGE>(insert_pos));
}
} else {
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
}
// return erase_stage, last_pos
return {erase_stage, last_pos};
} else {
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
}
};
} else if (dedup_type == Type::MAX) {
mut.copy_in_absolute(p_append, MARKER_MAX);
} else {
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
}
} else if (dedup_type == Type::MAX) {
len = MARKER_MAX;
} else {
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
std::memcpy(p_append, &len, sizeof(string_size_t));
}
p_fields->get_item_end_offset(index, node_size);
return FieldType::estimate_insert_one() + ns_oid_view_t(p_end).size();
} else {
- ceph_abort("N3 node is not nested");
+ ceph_abort_msg("N3 node is not nested");
}
}
container_range_t NODE_T::get_nxt_container(index_t index) const
{
if constexpr (std::is_same_v<FieldType, internal_fields_3_t>) {
- ceph_abort("N3 internal node doesn't have the right part");
+ ceph_abort_msg("N3 internal node doesn't have the right part");
} else {
auto item_start_offset = p_fields->get_item_start_offset(
index, node_size);
-(int)size_right);
return {p_insert_front, p_insert};
} else if constexpr (FIELD_TYPE == field_type_t::N2) {
- ceph_abort("not implemented");
+ ceph_abort_msg("not implemented");
} else {
- ceph_abort("impossible");
+ ceph_abort_msg("impossible");
}
}
#define IPA_TEMPLATE(FT, NT, Key) \
return 0;
}
if constexpr (std::is_same_v<FieldType, internal_fields_3_t>) {
- ceph_abort("not implemented");
+ ceph_abort_msg("not implemented");
} else {
mut.copy_in_absolute(
(void*)&node.p_fields->num_keys, num_keys_t(index));
assert(!node.is_level_tail());
assert(index < node.keys());
if constexpr (std::is_same_v<FieldType, internal_fields_3_t>) {
- ceph_abort("not implemented");
+ ceph_abort_msg("not implemented");
} else {
extent_len_t node_size = mut.get_length();
node_offset_t offset = node.p_fields->get_item_start_offset(
assert(p_left_bound == node.p_left_bound());
return FieldType::erase_at(mut, node.fields(), index, p_left_bound);
} else {
- ceph_abort("not implemented");
+ ceph_abort_msg("not implemented");
}
}
node.fields().get_item_end_offset(node.keys() - 1,
node_size);
} else if constexpr (FIELD_TYPE == field_type_t::N2) {
- ceph_abort("not implemented");
+ ceph_abort_msg("not implemented");
} else {
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
num_keys = node.keys() - 1;
} else {
if constexpr (std::is_same_v<FieldType, internal_fields_3_t>) {
std::ignore = node_size;
- ceph_abort("not implemented");
+ ceph_abort_msg("not implemented");
} else {
p_append_left = p_start + node.fields().get_key_start_offset(
node.keys(), node_size);
num_keys += items;
if constexpr (std::is_same_v<FieldType, internal_fields_3_t>) {
std::ignore = node_size;
- ceph_abort("not implemented");
+ ceph_abort_msg("not implemented");
} else {
// append left part forwards
node_offset_t offset_left_start = src.fields().get_key_start_offset(
const full_key_t<KT>& key, const value_input_t& value, const value_t*& p_value)
{
if constexpr (FIELD_TYPE == field_type_t::N3) {
- ceph_abort("not implemented");
+ ceph_abort_msg("not implemented");
} else {
- ceph_abort("should not happen");
+ ceph_abort_msg("should not happen");
}
}
} else if constexpr (FIELD_TYPE == field_type_t::N2) {
FieldType::append_key(*p_mut, partial_key, p_append_right);
} else {
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
return {p_mut, p_append_right};
}
} else if constexpr (FIELD_TYPE == field_type_t::N2) {
FieldType::append_key(*p_mut, key, p_append_right);
} else {
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
return {p_mut, p_append_right};
}
const Key& key, const value_input_t& value,
index_t index, node_offset_t size, const char* p_left_bound) {
if constexpr (FIELD_TYPE == field_type_t::N3) {
- ceph_abort("not implemented");
+ ceph_abort_msg("not implemented");
} else {
- ceph_abort("impossible");
+ ceph_abort_msg("impossible");
}
}
FieldType::append_offset(*p_mut, new_offset, p_append_left);
++num_keys;
} else {
- ceph_abort("not implemented");
+ ceph_abort_msg("not implemented");
}
}
static void insert_at(
NodeExtentMutable& mut, const Key& key,
const node_fields_2_t& node, index_t index, node_offset_t size_right) {
- ceph_abort("not implemented");
+ ceph_abort_msg("not implemented");
}
static void update_size_at(
NodeExtentMutable& mut, const node_fields_2_t& node, index_t index, int change) {
- ceph_abort("not implemented");
+ ceph_abort_msg("not implemented");
}
static void append_key(
NodeExtentMutable& mut, const key_t& key, char*& p_append) {
NodeExtentMutable& mut, const Key& key,
const internal_fields_3_t& node,
index_t index, node_offset_t size_right) {
- ceph_abort("not implemented");
+ ceph_abort_msg("not implemented");
}
static void update_size_at(
NodeExtentMutable& mut, const internal_fields_3_t& node,
index_t index, int change) {
- ceph_abort("not implemented");
+ ceph_abort_msg("not implemented");
}
node_header_t header;
}
break;
default:
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
// key == index ...
switch (mstat) {
assert(_index + 1 == container.keys());
return typename container_t::template Appender<KT>(p_mut, container, true);
} else {
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
}
if constexpr (!IS_BOTTOM) {
return typename container_t::template Appender<KT>(p_mut, container, true);
} else {
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
}
auto match = key <=> iter.get_key();
if (match == 0) {
if constexpr (IS_BOTTOM) {
- ceph_abort("insert conflict at current index!");
+ ceph_abort_msg("insert conflict at current index!");
} else {
// insert into the current index
auto nxt_container = iter.get_nxt_container();
assert(match == std::strong_ordering::equal);
if constexpr (IS_BOTTOM) {
// ceph_abort?
- ceph_abort("insert conflict at the previous index!");
+ ceph_abort_msg("insert conflict at the previous index!");
} else {
// insert into the previous index
auto nxt_container = iter.get_nxt_container();
return true;
} else {
if constexpr (IS_BOTTOM) {
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
} else {
assert(stage < STAGE);
bool compensate = NXT_STAGE_T::
iter.update_size(mut, _insert_size);
return p_value;
} else {
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
}
}
stage = STAGE;
_insert_size = insert_size(key, value);
} else {
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
if constexpr (IS_BOTTOM) {
return container_t::insert_at(
}
return this->_nxt;
} else {
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
}
typename NXT_STAGE_T::StagedIterator& get_nxt() {
if constexpr (!IS_BOTTOM) {
return this->_nxt;
} else {
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
}
StagedIterator& operator++() {
return false;
}
} else {
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
return false;;
}
}
auto nxt_container = iter.get_nxt_container();
this->_nxt.init_tail(p_mut, nxt_container, stage);
} else {
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
}
}
this->_nxt.init_empty(p_mut, p_append);
return this->_nxt;
} else {
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
}
typename NXT_STAGE_T::template StagedAppender<KT>&
this->_nxt.init_empty(p_mut, p_append);
return this->_nxt;
} else {
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
}
typename NXT_STAGE_T::template StagedAppender<KT>& get_nxt() {
assert(require_wrap_nxt);
return this->_nxt;
} else {
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
}
void wrap_nxt() {
appender->wrap_nxt(p_append);
++_index;
} else {
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
}
private:
}
return false;
} else {
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
}
}
compensate += ret_compensate;
return {ret_stage, compensate};
} else {
- ceph_abort("impossible path: left_pivot_key == right_first_key");
+ ceph_abort_msg("impossible path: left_pivot_key == right_first_key");
}
} else if (cmp == std::strong_ordering::less) {
// ok, do merge here
return {STAGE, compensate};
} else {
- ceph_abort("impossible path: left_pivot_key < right_first_key");
+ ceph_abort_msg("impossible path: left_pivot_key < right_first_key");
}
}
};
} else if (*match == MatchKindCMP::GT) {
return os << "GT";
} else {
- ceph_abort("impossble path");
+ ceph_abort_msg("impossble path");
}
}
#endif
return pos.nxt.nxt;
} else {
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
}
pos.nxt.index = 0;
return pos.nxt.nxt;
} else {
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
}
} else if (STAGE == STAGE_RIGHT) {
return {0u, {0u, std::move(pos)}};
} else {
- ceph_abort("impossible path");
+ ceph_abort_msg("impossible path");
}
}
// we don't actually store end cursor because it will hold a reference
// to an end leaf node and is not kept updated.
assert(p_cursor->is_end());
- ceph_abort("impossible");
+ ceph_abort_msg("impossible");
}
}
Cursor(Btree* p_tree, Ref<tree_cursor_t> _p_cursor) : p_tree(p_tree) {
if (_p_cursor->is_invalid()) {
// we don't create Cursor from an invalid tree_cursor_t.
- ceph_abort("impossible");
+ ceph_abort_msg("impossible");
} else if (_p_cursor->is_end()) {
// we don't actually store end cursor because it will hold a reference
// to an end leaf node and is not kept updated.
if (length != pin.get_length() || !pin.get_val().is_real_location()) {
SUBERRORT(seastore_tm, "{}~0x{:x} {} got wrong pin {}",
t, offset, length, T::TYPE, pin);
- ceph_abort("Impossible");
+ ceph_abort_msg("Impossible");
}
return this->read_pin<T>(t, std::move(pin), std::move(maybe_init));
});
if (!pin.get_val().is_real_location()) {
SUBERRORT(seastore_tm, "{} {} got wrong pin {}",
t, offset, T::TYPE, pin);
- ceph_abort("Impossible");
+ ceph_abort_msg("Impossible");
}
return this->read_pin<T>(t, std::move(pin), std::move(maybe_init));
});
if (core_expected != NULL_CORE && core_expected != core_found) {
ERROR("the mapping is inconsistent for pg {}: core {}, expected {}",
pgid, core_found, core_expected);
- ceph_abort("The pg mapping is inconsistent!");
+ ceph_abort_msg("The pg mapping is inconsistent!");
}
return seastar::make_ready_future<core_id_t>(core_found);
} else {
if (core_expected != core_found) {
ERROR("the mapping is inconsistent for pg {} (primary): core {}, expected {}",
pgid, core_found, core_expected);
- ceph_abort("The pg mapping is inconsistent!");
+ ceph_abort_msg("The pg mapping is inconsistent!");
}
// core_expected == core_found
DEBUG("mapping pg {} to core {} (primary): already mapped and expected",
if (core_found != core_to_update) {
ERROR("the mapping is inconsistent for pg {} (others): core {}, expected {}",
pgid, core_found, core_to_update);
- ceph_abort("The pg mapping is inconsistent!");
+ ceph_abort_msg("The pg mapping is inconsistent!");
}
DEBUG("mapping pg {} to core {} (others): already mapped",
pgid, core_to_update);
if (find_iter == pg_to_core.end()) {
ERROR("the mapping is inconsistent for pg {}: core not found, expected {}",
pgid, core_expected);
- ceph_abort("The pg mapping is inconsistent!");
+ ceph_abort_msg("The pg mapping is inconsistent!");
}
auto core_found = find_iter->second;
if (core_expected != NULL_CORE && core_found != core_expected) {
ERROR("the mapping is inconsistent for pg {}: core {}, expected {}",
pgid, core_found, core_expected);
- ceph_abort("The pg mapping is inconsistent!");
+ ceph_abort_msg("The pg mapping is inconsistent!");
}
DEBUG("returning pg {} mapping to core {} after broadcasted",
pgid, core_found);
auto find_iter = pg_to_core.find(pgid);
if (find_iter == pg_to_core.end()) {
ERROR("trying to remove non-exist mapping for pg {}", pgid);
- ceph_abort("The pg mapping is inconsistent!");
+ ceph_abort_msg("The pg mapping is inconsistent!");
}
DEBUG("calling primary to remove mapping for pg {}", pgid);
return container().invoke_on(
auto find_iter = primary_mapping.pg_to_core.find(pgid);
if (find_iter == primary_mapping.pg_to_core.end()) {
ERROR("trying to remove non-exist mapping for pg {} (primary)", pgid);
- ceph_abort("The pg mapping is inconsistent!");
+ ceph_abort_msg("The pg mapping is inconsistent!");
}
assert(find_iter->second != NULL_CORE);
auto count_iter = primary_mapping.core_to_num_pgs.find(find_iter->second);
auto find_iter = other_mapping.pg_to_core.find(pgid);
if (find_iter == other_mapping.pg_to_core.end()) {
ERROR("trying to remove non-exist mapping for pg {} (others)", pgid);
- ceph_abort("The pg mapping is inconsistent!");
+ ceph_abort_msg("The pg mapping is inconsistent!");
}
assert(find_iter->second != NULL_CORE);
other_mapping.pg_to_core.erase(find_iter);
pushes.clear();
break;
default:
- ceph_abort("impossible");
+ ceph_abort_msg("impossible");
break;
}
}
struct Crash : ScrubState<Crash, ScrubMachine> {
static constexpr std::string_view state_name = "Crash";
explicit Crash(my_context ctx) : ScrubState(ctx) {
- ceph_abort("Crash state impossible");
+ ceph_abort_msg("Crash state impossible");
}
};
});
}).handle_exception([FNAME, pgid](auto ep) {
INFO("pg {} saw exception on load {}", pgid, ep);
- ceph_abort("Could not load pg" == 0);
+ ceph_abort_msg("Could not load pg");
return seastar::make_exception_future<Ref<PG>>(ep);
});
}
void ms_handle_connect(
crimson::net::ConnectionRef,
seastar::shard_id) override {
- ceph_abort("impossible, server won't connect");
+ ceph_abort_msg("impossible, server won't connect");
}
void ms_handle_accept(
projects / ceph.git / commitdiff