From: Yingxin Cheng Date: Tue, 22 Sep 2020 07:39:57 +0000 (+0800) Subject: crimson/onode-staged-tree: fix errors about misaligned address access X-Git-Tag: v16.1.0~359^2~34 X-Git-Url: http://git-server-git.apps.pok.os.sepia.ceph.com/?a=commitdiff_plain;h=9b9a9e583112ab75121e6a368d7a39428a37334a;p=ceph.git crimson/onode-staged-tree: fix errors about misaligned address access Signed-off-by: Yingxin Cheng --- diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/node.cc b/src/crimson/os/seastore/onode_manager/staged-fltree/node.cc index 15a14ab79553..1fe1997315b9 100644 --- a/src/crimson/os/seastore/onode_manager/staged-fltree/node.cc +++ b/src/crimson/os/seastore/onode_manager/staged-fltree/node.cc @@ -262,6 +262,7 @@ node_future<> InternalNode::apply_child_split( // update pos => left_child to pos => right_child auto left_child_addr = left_child->impl->laddr(); + auto left_child_addr_packed = laddr_packed_t{left_child_addr}; auto right_child_addr = right_child->impl->laddr(); impl->replace_child_addr(pos, right_child_addr, left_child_addr); replace_track(pos, right_child, left_child); @@ -273,11 +274,11 @@ node_future<> InternalNode::apply_child_split( auto free_size = impl->free_size(); if (free_size >= insert_size) { // insert - auto p_value = impl->insert(left_key, left_child_addr, + auto p_value = impl->insert(left_key, left_child_addr_packed, insert_pos, insert_stage, insert_size); assert(impl->free_size() == free_size - insert_size); assert(insert_pos <= pos); - assert(*p_value == left_child_addr); + assert(p_value->value == left_child_addr); track_insert(insert_pos, insert_stage, left_child, right_child); validate_tracked_children(); return node_ertr::now(); @@ -297,10 +298,11 @@ node_future<> InternalNode::apply_child_split( insert_pos, insert_stage, insert_size](auto fresh_right) mutable { auto right_node = fresh_right.node; auto left_child_addr = left_child->impl->laddr(); + auto left_child_addr_packed = laddr_packed_t{left_child_addr}; auto [split_pos, is_insert_left, p_value] = impl->split_insert( - fresh_right.mut, *right_node->impl, left_key, left_child_addr, + fresh_right.mut, *right_node->impl, left_key, left_child_addr_packed, insert_pos, insert_stage, insert_size); - assert(*p_value == left_child_addr); + assert(p_value->value == left_child_addr); track_split(split_pos, right_node); if (is_insert_left) { track_insert(insert_pos, insert_stage, left_child); @@ -324,9 +326,9 @@ node_future> InternalNode::allocate_root( ).safe_then([c, old_root_addr, super = std::move(super)](auto fresh_node) mutable { auto root = fresh_node.node; - const laddr_t* p_value = root->impl->get_p_value(search_position_t::end()); + auto p_value = root->impl->get_p_value(search_position_t::end()); fresh_node.mut.copy_in_absolute( - const_cast(p_value), old_root_addr); + const_cast(p_value), old_root_addr); root->make_root_from(c, std::move(super), old_root_addr); return root; }); @@ -335,7 +337,7 @@ node_future> InternalNode::allocate_root( node_future> InternalNode::lookup_smallest(context_t c) { auto position = search_position_t::begin(); - laddr_t child_addr = *impl->get_p_value(position); + laddr_t child_addr = impl->get_p_value(position)->value; return get_or_track_child(c, position, child_addr ).safe_then([c](auto child) { return child->lookup_smallest(c); @@ -347,7 +349,7 @@ InternalNode::lookup_largest(context_t c) { // NOTE: unlike LeafNode::lookup_largest(), this only works for the tail // internal node to return the tail child address. auto position = search_position_t::end(); - laddr_t child_addr = *impl->get_p_value(position); + laddr_t child_addr = impl->get_p_value(position)->value; return get_or_track_child(c, position, child_addr).safe_then([c](auto child) { return child->lookup_largest(c); }); @@ -357,7 +359,7 @@ node_future InternalNode::lower_bound_tracked( context_t c, const key_hobj_t& key, MatchHistory& history) { auto result = impl->lower_bound(key, history); - return get_or_track_child(c, result.position, *result.p_value + return get_or_track_child(c, result.position, result.p_value->value ).safe_then([c, &key, &history](auto child) { // XXX(multi-type): pass result.mstat to child return child->lower_bound_tracked(c, key, history); @@ -473,7 +475,7 @@ void InternalNode::validate_child(const Node& child) const { assert(impl->level() - 1 == child.impl->level()); assert(this == child.parent_info().ptr); auto& child_pos = child.parent_info().position; - assert(*impl->get_p_value(child_pos) == child.impl->laddr()); + assert(impl->get_p_value(child_pos)->value == child.impl->laddr()); if (child_pos.is_end()) { assert(impl->is_level_tail()); assert(child.impl->is_level_tail()); diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_visitor.h b/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_visitor.h index 30e65a46f397..2668b916655e 100644 --- a/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_visitor.h +++ b/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_visitor.h @@ -101,7 +101,7 @@ class NodeExtentT { } void update_child_addr_replayable( - const laddr_t new_addr, laddr_t* p_addr) { + const laddr_t new_addr, laddr_packed_t* p_addr) { assert(state != state_t::PENDING_MUTATE); // TODO: encode params to recorder as delta return layout_t::update_child_addr(*mut, new_addr, p_addr); diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/node_impl.h b/src/crimson/os/seastore/onode_manager/staged-fltree/node_impl.h index acd00c964e5a..a01e73eff010 100644 --- a/src/crimson/os/seastore/onode_manager/staged-fltree/node_impl.h +++ b/src/crimson/os/seastore/onode_manager/staged-fltree/node_impl.h @@ -50,7 +50,7 @@ class InternalNodeImpl : public NodeImpl { virtual ~InternalNodeImpl() = default; #pragma GCC diagnostic ignored "-Woverloaded-virtual" - virtual const laddr_t* get_p_value( + virtual const laddr_packed_t* get_p_value( const search_position_t&, key_view_t* = nullptr, internal_marker_t = {}) const { assert(false && "impossible path"); @@ -62,13 +62,13 @@ class InternalNodeImpl : public NodeImpl { assert(false && "impossible path"); } #pragma GCC diagnostic ignored "-Woverloaded-virtual" - virtual const laddr_t* insert( - const key_view_t&, const laddr_t&, search_position_t&, match_stage_t&, node_offset_t&) { + virtual const laddr_packed_t* insert( + const key_view_t&, const laddr_packed_t&, search_position_t&, match_stage_t&, node_offset_t&) { assert(false && "impossible path"); } #pragma GCC diagnostic ignored "-Woverloaded-virtual" - virtual std::tuple split_insert( - NodeExtentMutable&, NodeImpl&, const key_view_t&, const laddr_t&, + virtual std::tuple split_insert( + NodeExtentMutable&, NodeImpl&, const key_view_t&, const laddr_packed_t&, search_position_t&, match_stage_t&, node_offset_t&) { assert(false && "impossible path"); } diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/node_layout.h b/src/crimson/os/seastore/onode_manager/staged-fltree/node_layout.h index c3244aa3154e..0c6e478807dc 100644 --- a/src/crimson/os/seastore/onode_manager/staged-fltree/node_layout.h +++ b/src/crimson/os/seastore/onode_manager/staged-fltree/node_layout.h @@ -124,7 +124,7 @@ class NodeLayoutT final : public InternalNodeImpl, public LeafNodeImpl { auto value_ptr = node_stage.get_end_p_laddr(); int offset = reinterpret_cast(value_ptr) - p_start; os << "\n tail value: 0x" - << std::hex << *value_ptr << std::dec + << std::hex << value_ptr->value << std::dec << " " << size << "B" << " @" << offset << "B"; } @@ -322,9 +322,9 @@ class NodeLayoutT final : public InternalNodeImpl, public LeafNodeImpl { void replace_child_addr( const search_position_t& pos, laddr_t dst, laddr_t src) override { if constexpr (NODE_TYPE == node_type_t::INTERNAL) { - const laddr_t* p_value = get_p_value(pos); - assert(*p_value == src); - extent.update_child_addr_replayable(dst, const_cast(p_value)); + const laddr_packed_t* p_value = get_p_value(pos); + assert(p_value->value == src); + extent.update_child_addr_replayable(dst, const_cast(p_value)); } else { assert(false && "impossible path"); } @@ -334,16 +334,17 @@ class NodeLayoutT final : public InternalNodeImpl, public LeafNodeImpl { const key_view_t& key, const laddr_t& value, search_position_t& insert_pos) const override { if constexpr (NODE_TYPE == node_type_t::INTERNAL) { + auto packed_value = laddr_packed_t{value}; auto& node_stage = extent.read(); match_stage_t insert_stage; node_offset_t insert_size; if (unlikely(!node_stage.keys())) { assert(insert_pos.is_end()); insert_stage = STAGE; - insert_size = STAGE_T::template insert_size(key, value); + insert_size = STAGE_T::template insert_size(key, packed_value); } else { std::tie(insert_stage, insert_size) = STAGE_T::evaluate_insert( - node_stage, key, value, cast_down(insert_pos), true); + node_stage, key, packed_value, cast_down(insert_pos), true); } return {insert_stage, insert_size}; } else { diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/node_layout_replayable.h b/src/crimson/os/seastore/onode_manager/staged-fltree/node_layout_replayable.h index ef01d2cc7b41..398e2f66f1cf 100644 --- a/src/crimson/os/seastore/onode_manager/staged-fltree/node_layout_replayable.h +++ b/src/crimson/os/seastore/onode_manager/staged-fltree/node_layout_replayable.h @@ -64,7 +64,7 @@ struct NodeLayoutReplayableT { } static void update_child_addr( - NodeExtentMutable& mut, const laddr_t new_addr, laddr_t* p_addr) { + NodeExtentMutable& mut, const laddr_t new_addr, laddr_packed_t* p_addr) { assert(NODE_TYPE == node_type_t::INTERNAL); mut.copy_in_absolute(p_addr, new_addr); } diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/node_types.h b/src/crimson/os/seastore/onode_manager/staged-fltree/node_types.h index 2466588e3f0a..c1b4d190da58 100644 --- a/src/crimson/os/seastore/onode_manager/staged-fltree/node_types.h +++ b/src/crimson/os/seastore/onode_manager/staged-fltree/node_types.h @@ -43,4 +43,8 @@ inline std::ostream& operator<<(std::ostream &os, const node_type_t& type) { return os; } +struct laddr_packed_t { + laddr_t value; +} __attribute__((packed)); + } diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/stages/item_iterator_stage.h b/src/crimson/os/seastore/onode_manager/staged-fltree/stages/item_iterator_stage.h index 6c7e928b807a..3c1725d5f041 100644 --- a/src/crimson/os/seastore/onode_manager/staged-fltree/stages/item_iterator_stage.h +++ b/src/crimson/os/seastore/onode_manager/staged-fltree/stages/item_iterator_stage.h @@ -100,7 +100,7 @@ class item_iterator_t { void next_item_range(const char* p_end) const { auto p_item_end = p_end - sizeof(node_offset_t); assert(p_items_start < p_item_end); - back_offset = *reinterpret_cast(p_item_end); + back_offset = reinterpret_cast(p_item_end)->value; assert(back_offset); const char* p_item_start = p_item_end - back_offset; assert(p_items_start <= p_item_start); diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/stages/key_layout.h b/src/crimson/os/seastore/onode_manager/staged-fltree/stages/key_layout.h index 01caa32341c7..f0e2673a8ff1 100644 --- a/src/crimson/os/seastore/onode_manager/staged-fltree/stages/key_layout.h +++ b/src/crimson/os/seastore/onode_manager/staged-fltree/stages/key_layout.h @@ -34,6 +34,10 @@ template<> struct _full_key_type { using type = key_hobj_t; }; template using full_key_t = typename _full_key_type::type; +struct node_offset_packed_t { + node_offset_t value; +} __attribute__((packed)); + // TODO: consider alignments struct shard_pool_t { bool operator==(const shard_pool_t& x) const { diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/stages/node_stage.cc b/src/crimson/os/seastore/onode_manager/staged-fltree/stages/node_stage.cc index d1c1394a051f..f7f326daeac2 100644 --- a/src/crimson/os/seastore/onode_manager/staged-fltree/stages/node_stage.cc +++ b/src/crimson/os/seastore/onode_manager/staged-fltree/stages/node_stage.cc @@ -302,7 +302,7 @@ char* APPEND_T::wrap() { assert(p_src); if constexpr (NODE_TYPE == node_type_t::INTERNAL) { if (p_src->is_level_tail()) { - laddr_t tail_value = *p_src->get_end_p_laddr(); + laddr_t tail_value = p_src->get_end_p_laddr()->value; p_append_right -= sizeof(laddr_t); assert(p_append_left <= p_append_right); p_mut->copy_in_absolute(p_append_right, tail_value); diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/stages/node_stage.h b/src/crimson/os/seastore/onode_manager/staged-fltree/stages/node_stage.h index 73703fd7d657..4edeab5912ff 100644 --- a/src/crimson/os/seastore/onode_manager/staged-fltree/stages/node_stage.h +++ b/src/crimson/os/seastore/onode_manager/staged-fltree/stages/node_stage.h @@ -51,18 +51,17 @@ class node_extent_t { size_t total_size() const { return p_fields->total_size(); } const char* p_left_bound() const; template - std::enable_if_t + std::enable_if_t get_end_p_laddr() const { assert(is_level_tail()); if constexpr (FIELD_TYPE == field_type_t::N3) { - #pragma GCC diagnostic ignored "-Waddress-of-packed-member" return &p_fields->child_addrs[keys()]; } else { auto offset_start = p_fields->get_item_end_offset(keys()); assert(offset_start <= FieldType::SIZE); - offset_start -= sizeof(laddr_t); + offset_start -= sizeof(laddr_packed_t); auto p_addr = p_start() + offset_start; - return reinterpret_cast(p_addr); + return reinterpret_cast(p_addr); } } @@ -84,7 +83,6 @@ class node_extent_t { get_p_value(size_t index) const { assert(index < keys()); if constexpr (NODE_TYPE == node_type_t::INTERNAL) { - #pragma GCC diagnostic ignored "-Waddress-of-packed-member" return &p_fields->child_addrs[index]; } else { auto range = get_nxt_container(index); diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/stages/node_stage_layout.h b/src/crimson/os/seastore/onode_manager/staged-fltree/stages/node_stage_layout.h index 67405a376a0f..a79a364b3d69 100644 --- a/src/crimson/os/seastore/onode_manager/staged-fltree/stages/node_stage_layout.h +++ b/src/crimson/os/seastore/onode_manager/staged-fltree/stages/node_stage_layout.h @@ -373,7 +373,7 @@ struct _internal_fields_3_t { node_header_t header; num_keys_t num_keys = 0u; snap_gen_t keys[MAX_NUM_KEYS]; - laddr_t child_addrs[MAX_NUM_KEYS]; + laddr_packed_t child_addrs[MAX_NUM_KEYS]; } __attribute__((packed)); static_assert(_internal_fields_3_t::SIZE <= NODE_BLOCK_SIZE && _internal_fields_3_t::SIZE > NODE_BLOCK_SIZE); diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/stages/stage.h b/src/crimson/os/seastore/onode_manager/staged-fltree/stages/stage.h index ac82e03a1a09..cc57d432ccc3 100644 --- a/src/crimson/os/seastore/onode_manager/staged-fltree/stages/stage.h +++ b/src/crimson/os/seastore/onode_manager/staged-fltree/stages/stage.h @@ -1246,7 +1246,7 @@ struct staged { if constexpr (NODE_TYPE == node_type_t::LEAF) { os << *value_ptr; } else { - os << "0x" << std::hex << *value_ptr << std::dec; + os << "0x" << std::hex << value_ptr->value << std::dec; } os << " " << size << "B" << " @" << offset << "B"; diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/stages/stage_types.h b/src/crimson/os/seastore/onode_manager/staged-fltree/stages/stage_types.h index 6f30a1548573..b900d666a79b 100644 --- a/src/crimson/os/seastore/onode_manager/staged-fltree/stages/stage_types.h +++ b/src/crimson/os/seastore/onode_manager/staged-fltree/stages/stage_types.h @@ -284,7 +284,7 @@ struct memory_range_t { enum class ContainerType { ITERATIVE, INDEXABLE }; template struct value_type; -template<> struct value_type { using type = laddr_t; }; +template<> struct value_type { using type = laddr_packed_t; }; template<> struct value_type { using type = onode_t; }; template using value_type_t = typename value_type::type; diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/stages/sub_items_stage.cc b/src/crimson/os/seastore/onode_manager/staged-fltree/stages/sub_items_stage.cc index 06263c53ebdf..7788d283b800 100644 --- a/src/crimson/os/seastore/onode_manager/staged-fltree/stages/sub_items_stage.cc +++ b/src/crimson/os/seastore/onode_manager/staged-fltree/stages/sub_items_stage.cc @@ -8,9 +8,9 @@ namespace crimson::os::seastore::onode { template -const laddr_t* internal_sub_items_t::insert_at( +const laddr_packed_t* internal_sub_items_t::insert_at( NodeExtentMutable& mut, const internal_sub_items_t& sub_items, - const full_key_t& key, const laddr_t& value, + const full_key_t& key, const laddr_packed_t& value, size_t index, node_offset_t size, const char* p_left_bound) { assert(index <= sub_items.keys()); assert(size == estimate_insert(key, value)); @@ -24,9 +24,9 @@ const laddr_t* internal_sub_items_t::insert_at( mut.copy_in_absolute(p_insert, item); return &reinterpret_cast(p_insert)->value; } -template const laddr_t* internal_sub_items_t::insert_at( +template const laddr_packed_t* internal_sub_items_t::insert_at( NodeExtentMutable&, const internal_sub_items_t&, const full_key_t&, - const laddr_t&, size_t, node_offset_t, const char*); + const laddr_packed_t&, size_t, node_offset_t, const char*); size_t internal_sub_items_t::trim_until( NodeExtentMutable&, internal_sub_items_t& items, size_t index) { @@ -55,8 +55,8 @@ void internal_sub_items_t::Appender::append( template void internal_sub_items_t::Appender::append( - const full_key_t& key, const laddr_t& value, const laddr_t*& p_value) { - assert(pp_value == nullptr); + const full_key_t& key, const laddr_packed_t& value, + const laddr_packed_t*& p_value) { p_append -= sizeof(internal_sub_item_t); auto item = internal_sub_item_t{snap_gen_t::from_key(key), value}; p_mut->copy_in_absolute(p_append, item); @@ -86,8 +86,8 @@ const onode_t* leaf_sub_items_t::insert_at( // c. compensate affected offsets auto item_size = value.size + sizeof(snap_gen_t); for (auto i = index; i < sub_items.keys(); ++i) { - const node_offset_t& offset_i = sub_items.get_offset(i); - mut.copy_in_absolute((void*)&offset_i, node_offset_t(offset_i + item_size)); + const node_offset_packed_t& offset_i = sub_items.get_offset(i); + mut.copy_in_absolute((void*)&offset_i, node_offset_t(offset_i.value + item_size)); } // d. [item(index-1) ... item(0) ... offset(index)] <<< sizeof(node_offset_t) @@ -162,7 +162,7 @@ char* leaf_sub_items_t::Appender::wrap() { int compensate = (last_offset - op_src->get_offset_to_end(arg.from)); node_offset_t offset; for (auto i = arg.from; i < arg.from + arg.items; ++i) { - offset = op_src->get_offset(i) + compensate; + offset = op_src->get_offset(i).value + compensate; p_cur -= sizeof(node_offset_t); p_mut->copy_in_absolute(p_cur, offset); } diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/stages/sub_items_stage.h b/src/crimson/os/seastore/onode_manager/staged-fltree/stages/sub_items_stage.h index 124a47b035d8..12594d183c0d 100644 --- a/src/crimson/os/seastore/onode_manager/staged-fltree/stages/sub_items_stage.h +++ b/src/crimson/os/seastore/onode_manager/staged-fltree/stages/sub_items_stage.h @@ -15,11 +15,10 @@ class NodeExtentMutable; struct internal_sub_item_t { const snap_gen_t& get_key() const { return key; } - #pragma GCC diagnostic ignored "-Waddress-of-packed-member" - const laddr_t* get_p_value() const { return &value; } + const laddr_packed_t* get_p_value() const { return &value; } snap_gen_t key; - laddr_t value; + laddr_packed_t value; } __attribute__((packed)); /* @@ -56,7 +55,7 @@ class internal_sub_items_t { size_t size_before(size_t index) const { return index * sizeof(internal_sub_item_t); } - const laddr_t* get_p_value(size_t index) const { + const laddr_packed_t* get_p_value(size_t index) const { assert(index < num_items); return (p_first_item - index)->get_p_value(); } @@ -64,14 +63,15 @@ class internal_sub_items_t { static node_offset_t header_size() { return 0u; } template - static node_offset_t estimate_insert(const full_key_t&, const laddr_t&) { + static node_offset_t estimate_insert( + const full_key_t&, const laddr_packed_t&) { return sizeof(internal_sub_item_t); } template - static const laddr_t* insert_at( + static const laddr_packed_t* insert_at( NodeExtentMutable&, const internal_sub_items_t&, - const full_key_t&, const laddr_t&, + const full_key_t&, const laddr_packed_t&, size_t index, node_offset_t size, const char* p_left_bound); static size_t trim_until(NodeExtentMutable&, internal_sub_items_t&, size_t); @@ -90,10 +90,9 @@ class internal_sub_items_t::Appender { Appender(NodeExtentMutable* p_mut, char* p_append) : p_mut{p_mut}, p_append{p_append} {} void append(const internal_sub_items_t& src, size_t from, size_t items); - void append(const full_key_t&, const laddr_t&, const laddr_t*&); + void append(const full_key_t&, const laddr_packed_t&, const laddr_packed_t*&); char* wrap() { return p_append; } private: - const laddr_t** pp_value = nullptr; NodeExtentMutable* p_mut; char* p_append; }; @@ -127,7 +126,7 @@ class leaf_sub_items_t { assert(keys()); auto _p_offsets = _p_num_keys - sizeof(node_offset_t); assert(range.p_start < _p_offsets); - p_offsets = reinterpret_cast(_p_offsets); + p_offsets = reinterpret_cast(_p_offsets); p_items_end = reinterpret_cast(&get_offset(keys() - 1)); assert(range.p_start < p_items_end); assert(range.p_start == p_start()); @@ -141,18 +140,18 @@ class leaf_sub_items_t { const char* p_start() const { return get_item_end(keys()); } - const node_offset_t& get_offset(size_t index) const { + const node_offset_packed_t& get_offset(size_t index) const { assert(index < keys()); return *(p_offsets - index); } const node_offset_t get_offset_to_end(size_t index) const { assert(index <= keys()); - return index == 0 ? 0 : get_offset(index - 1); + return index == 0 ? 0 : get_offset(index - 1).value; } const char* get_item_start(size_t index) const { - return p_items_end - get_offset(index); + return p_items_end - get_offset(index).value; } const char* get_item_end(size_t index) const { @@ -179,7 +178,7 @@ class leaf_sub_items_t { --index; auto ret = sizeof(num_keys_t) + (index + 1) * sizeof(node_offset_t) + - get_offset(index); + get_offset(index).value; return ret; } const onode_t* get_p_value(size_t index) const { @@ -211,7 +210,7 @@ class leaf_sub_items_t { private: // TODO: support unaligned access const num_keys_t* p_num_keys; - const node_offset_t* p_offsets; + const node_offset_packed_t* p_offsets; const char* p_items_end; }; diff --git a/src/test/crimson/seastore/onode_tree/test_staged_fltree.cc b/src/test/crimson/seastore/onode_tree/test_staged_fltree.cc index 689149e075a7..448105565c12 100644 --- a/src/test/crimson/seastore/onode_tree/test_staged_fltree.cc +++ b/src/test/crimson/seastore/onode_tree/test_staged_fltree.cc @@ -167,6 +167,7 @@ TEST_F(a_basic_test_t, 1_basic_sizes) onode_t value = {2}; #define _STAGE_T(NodeType) node_to_stage_t #define NXT_T(StageType) staged + laddr_packed_t i_value{0}; logger().info("\n" "Bytes of a key-value insertion (full-string):\n" " s-p-c, 'n'-'o', s-g => onode_t(2): typically internal 41B, leaf 35B\n" @@ -178,15 +179,15 @@ TEST_F(a_basic_test_t, 1_basic_sizes) " LeafNode1: {} {} {}\n" " LeafNode2: {} {}\n" " LeafNode3: {}", - _STAGE_T(InternalNode0)::template insert_size(key_view, 0), - NXT_T(_STAGE_T(InternalNode0))::template insert_size(key_view, 0), - NXT_T(NXT_T(_STAGE_T(InternalNode0)))::template insert_size(key_view, 0), - _STAGE_T(InternalNode1)::template insert_size(key_view, 0), - NXT_T(_STAGE_T(InternalNode1))::template insert_size(key_view, 0), - NXT_T(NXT_T(_STAGE_T(InternalNode1)))::template insert_size(key_view, 0), - _STAGE_T(InternalNode2)::template insert_size(key_view, 0), - NXT_T(_STAGE_T(InternalNode2))::template insert_size(key_view, 0), - _STAGE_T(InternalNode3)::template insert_size(key_view, 0), + _STAGE_T(InternalNode0)::template insert_size(key_view, i_value), + NXT_T(_STAGE_T(InternalNode0))::template insert_size(key_view, i_value), + NXT_T(NXT_T(_STAGE_T(InternalNode0)))::template insert_size(key_view, i_value), + _STAGE_T(InternalNode1)::template insert_size(key_view, i_value), + NXT_T(_STAGE_T(InternalNode1))::template insert_size(key_view, i_value), + NXT_T(NXT_T(_STAGE_T(InternalNode1)))::template insert_size(key_view, i_value), + _STAGE_T(InternalNode2)::template insert_size(key_view, i_value), + NXT_T(_STAGE_T(InternalNode2))::template insert_size(key_view, i_value), + _STAGE_T(InternalNode3)::template insert_size(key_view, i_value), _STAGE_T(LeafNode0)::template insert_size(key, value), NXT_T(_STAGE_T(LeafNode0))::template insert_size(key, value), NXT_T(NXT_T(_STAGE_T(LeafNode0)))::template insert_size(key, value),