crimson/os/seastore: remove fixed-kv-btree parent<->child pointer codes

from FixedKVNodes

FixedKV(Internal/Leaf)Node inherit parent<->child pointer functions from
linked tree nodes instead.

Signed-off-by: Xuehan Xu <[email protected]>

Author: xxhdx1985126

src/crimson/os/seastore/CMakeLists.txt

@@ -1,6 +1,7 @@
 set(crimson_seastore_srcs
   cached_extent.cc
   lba_mapping.cc
+  logical_child_node.cc
   seastore_types.cc
   segment_manager.cc
   segment_manager/ephemeral.cc
@@ -20,7 +21,6 @@ set(crimson_seastore_srcs
   omap_manager.cc
   omap_manager/btree/btree_omap_manager.cc
   omap_manager/btree/omap_btree_node_impl.cc
-  btree/fixed_kv_node.cc
   onode.cc
   onode_manager/staged-fltree/node.cc
   onode_manager/staged-fltree/node_extent_manager.cc

src/crimson/os/seastore/backref/backref_tree_node.h

@@ -5,6 +5,10 @@
 
 #include "crimson/os/seastore/btree/fixed_kv_node.h"
 
+namespace crimson::os::seastore {
+class LogicalChildNode;
+}
+
 namespace crimson::os::seastore::backref {
 
 using backref_node_meta_t = fixed_kv_node_meta_t<paddr_t>;
@@ -86,6 +90,7 @@ class BackrefInternalNode
     check_capacity(BACKREF_NODE_SIZE),
     "INTERNAL_NODE_CAPACITY doesn't fit in BACKREF_NODE_SIZE");
 public:
+  using key_type = paddr_t;
   template <typename... T>
   BackrefInternalNode(T&&... t) :
     FixedKVInternalNode(std::forward<T>(t)...) {}
@@ -104,12 +109,15 @@ class BackrefLeafNode
       paddr_t, paddr_le_t,
       backref_map_val_t, backref_map_val_le_t,
       BACKREF_NODE_SIZE,
+      BackrefInternalNode,
       BackrefLeafNode,
+      LogicalChildNode,
       false> {
   static_assert(
     check_capacity(BACKREF_NODE_SIZE),
     "LEAF_NODE_CAPACITY doesn't fit in BACKREF_NODE_SIZE");
 public:
+  using key_type = paddr_t;
   template <typename... T>
   BackrefLeafNode(T&&... t) :
     FixedKVLeafNode(std::forward<T>(t)...) {}
@@ -124,7 +132,7 @@ class BackrefLeafNode
     const_iterator iter,
     paddr_t key,
     backref_map_val_t val,
-    LogicalCachedExtent*) final {
+    LogicalChildNode*) final {
     journal_insert(
       iter,
       key,
@@ -136,7 +144,7 @@ class BackrefLeafNode
   void update(
     const_iterator iter,
     backref_map_val_t val,
-    LogicalCachedExtent*) final {
+    LogicalChildNode*) final {
     return journal_update(
       iter,
       val,

src/crimson/os/seastore/backref/btree_backref_manager.cc

@@ -47,24 +47,21 @@ const get_phy_tree_root_node_ret get_phy_tree_root_node<
   }
 }
 
-template <typename ROOT>
-void link_phy_tree_root_node(RootBlockRef &root_block, ROOT* backref_root) {
-  root_block->backref_root_node = backref_root;
-  ceph_assert(backref_root != nullptr);
-  backref_root->root_block = root_block;
-}
-
-template void link_phy_tree_root_node(
-  RootBlockRef &root_block, backref::BackrefInternalNode* backref_root);
-template void link_phy_tree_root_node(
-  RootBlockRef &root_block, backref::BackrefLeafNode* backref_root);
-template void link_phy_tree_root_node(
-  RootBlockRef &root_block, backref::BackrefNode* backref_root);
+template <typename RootT>
+class TreeRootLinker<RootBlock, RootT> {
+public:
+  static void link_root(RootBlockRef &root_block, RootT* backref_root) {
+    root_block->backref_root_node = backref_root;
+    ceph_assert(backref_root != nullptr);
+    backref_root->parent_of_root = root_block;
+  }
+  static void unlink_root(RootBlockRef &root_block) {
+    root_block->backref_root_node = nullptr;
+  }
+};
 
-template <>
-void unlink_phy_tree_root_node<paddr_t>(RootBlockRef &root_block) {
-  root_block->backref_root_node = nullptr;
-}
+template class TreeRootLinker<RootBlock, backref::BackrefInternalNode>;
+template class TreeRootLinker<RootBlock, backref::BackrefLeafNode>;
 
 }
 

src/crimson/os/seastore/backref/btree_backref_manager.h

@@ -15,7 +15,7 @@ class BtreeBackrefMapping : public BackrefMapping {
     : BackrefMapping(ctx) {}
   BtreeBackrefMapping(
     op_context_t<paddr_t> ctx,
-    CachedExtentRef parent,
+    BackrefLeafNodeRef parent,
     uint16_t pos,
     backref_map_val_t &val,
     backref_node_meta_t &&meta)

src/crimson/os/seastore/btree/fixed_kv_btree.h

@@ -14,21 +14,14 @@
 #include "crimson/os/seastore/seastore_types.h"
 #include "crimson/os/seastore/btree/btree_range_pin.h"
 #include "crimson/os/seastore/root_block.h"
+#include "crimson/os/seastore/linked_tree_node.h"
 
 namespace crimson::os::seastore::lba_manager::btree {
 struct lba_map_val_t;
 }
 
 namespace crimson::os::seastore {
 
-bool is_valid_child_ptr(ChildableCachedExtent* child);
-
-bool is_reserved_ptr(ChildableCachedExtent* child);
-
-inline ChildableCachedExtent* get_reserved_ptr() {
-  return (ChildableCachedExtent*)0x1;
-}
-
 template <typename T>
 phy_tree_root_t& get_phy_tree_root(root_t& r);
 
@@ -40,12 +33,6 @@ const get_phy_tree_root_node_ret get_phy_tree_root_node(
   const RootBlockRef &root_block,
   op_context_t<key_t> c);
 
-template <typename ROOT_T>
-void link_phy_tree_root_node(RootBlockRef &root_block, ROOT_T* root_node);
-
-template <typename T>
-void unlink_phy_tree_root_node(RootBlockRef &root_block);
-
 template <typename T>
 Transaction::tree_stats_t& get_tree_stats(Transaction &t);
 
@@ -351,7 +338,7 @@ class FixedKVBtree {
   template <typename T>
   void set_root_node(const TCachedExtentRef<T> &root_node) {
     static_assert(std::is_base_of_v<typename internal_node_t::base_t, T>);
-    link_phy_tree_root_node(root_block, root_node.get());
+    TreeRootLinker<RootBlock, T>::link_root(root_block, root_node.get());
   }
 
   auto get_root_node(op_context_t<node_key_t> c) const {
@@ -373,7 +360,7 @@ class FixedKVBtree {
     root_leaf->range = meta;
     get_tree_stats<self_type>(c.trans).depth = 1u;
     get_tree_stats<self_type>(c.trans).extents_num_delta++;
-    link_phy_tree_root_node(root_block, root_leaf.get());
+    TreeRootLinker<RootBlock, leaf_node_t>::link_root(root_block, root_leaf.get());
     return phy_tree_root_t{root_leaf->get_paddr(), 1u};
   }
 
@@ -495,6 +482,7 @@ class FixedKVBtree {
     return upper_bound(c, min_max_t<node_key_t>::max);
   }
 
+#ifdef UNIT_TESTS_BUILT
   template <typename child_node_t, typename node_t, bool lhc = leaf_has_children,
            typename std::enable_if<lhc, int>::type = 0>
   void check_node(
@@ -532,8 +520,8 @@ class FixedKVBtree {
           if (node->is_pending()) {
             auto &n = node->get_stable_for_key(i->get_key());
             assert(cnode->get_parent_node().get() == &n);
-            auto pos = n.lower_bound_offset(i->get_key());
-            assert(pos < n.get_node_size());
+            auto pos = n.lower_bound(i->get_key()).get_offset();
+            assert(pos < n.get_size());
             assert(n.children[pos] == cnode.get());
           } else {
             assert(cnode->get_parent_node().get() == node.get());
@@ -547,8 +535,8 @@ class FixedKVBtree {
             if (node->is_mutation_pending()) {
               auto &n = node->get_stable_for_key(i->get_key());
               assert(prior.get_parent_node().get() == &n);
-              auto pos = n.lower_bound_offset(i->get_key());
-              assert(pos < n.get_node_size());
+              auto pos = n.lower_bound(i->get_key()).get_offset();
+              assert(pos < n.get_size());
               assert(n.children[pos] == &prior);
             } else {
               assert(prior.get_parent_node().get() == node.get());
@@ -567,11 +555,12 @@ class FixedKVBtree {
           ceph_abort("impossible");
         }
       } else if (ret == Transaction::get_extent_ret::ABSENT) {
-        ChildableCachedExtent* child = nullptr;
+        BaseChildNode<std::remove_reference_t<decltype(*node)>,
+                      node_key_t>* child = nullptr;
         if (node->is_pending()) {
           auto &n = node->get_stable_for_key(i->get_key());
-          auto pos = n.lower_bound_offset(i->get_key());
-          assert(pos < n.get_node_size());
+          auto pos = n.lower_bound(i->get_key()).get_offset();
+          assert(pos < n.get_size());
           child = n.children[pos];
         } else {
           child = node->children[i->get_offset()];
@@ -601,7 +590,7 @@ class FixedKVBtree {
             }
           }
         } else {
-          auto c = (child_node_t*)child;
+          auto c = static_cast<child_node_t*>(child);
           assert(c->has_parent_tracker());
           assert(c->get_parent_node().get() == node.get()
             || (node->is_pending() && c->is_stable()
@@ -634,12 +623,16 @@ class FixedKVBtree {
       if (depth > 1) {
         auto &node = iter.get_internal(depth).node;
         assert(node->is_valid());
-        check_node<typename internal_node_t::base_t>(c, node);
+        if (depth > 2 ) {
+          check_node<internal_node_t>(c, node);
+        } else {
+          check_node<leaf_node_t>(c, node);
+        }
       } else {
         assert(depth == 1);
         auto &node = iter.leaf.node;
         assert(node->is_valid());
-        check_node<LogicalCachedExtent>(c, node);
+        check_node<typename leaf_node_t::base_child_node_t>(c, node);
       }
       return seastar::now();
     };
@@ -666,6 +659,7 @@ class FixedKVBtree {
         &checker);
     });
   }
+#endif
 
   using iterate_repeat_ret_inner = base_iertr::future<
     seastar::stop_iteration>;
@@ -730,7 +724,7 @@ class FixedKVBtree {
     iterator iter,
     node_key_t laddr,
     node_val_t val,
-    LogicalCachedExtent* nextent
+    leaf_node_t::base_child_node_t* nextent
   ) {
     LOG_PREFIX(FixedKVBtree::insert);
     SUBTRACET(
@@ -780,7 +774,7 @@ class FixedKVBtree {
     op_context_t<node_key_t> c,
     node_key_t laddr,
     node_val_t val,
-    LogicalCachedExtent* nextent) {
+    leaf_node_t::base_child_node_t* nextent) {
     return lower_bound(
       c, laddr
     ).si_then([this, c, laddr, val, nextent](auto iter) {
@@ -804,7 +798,7 @@ class FixedKVBtree {
     op_context_t<node_key_t> c,
     iterator iter,
     node_val_t val,
-    LogicalCachedExtent* nextent)
+    leaf_node_t::base_child_node_t* nextent)
   {
     LOG_PREFIX(FixedKVBtree::update);
     SUBTRACET(
@@ -1082,13 +1076,15 @@ class FixedKVBtree {
 
   using update_internal_mapping_iertr = base_iertr;
   using update_internal_mapping_ret = update_internal_mapping_iertr::future<>;
+  template <typename T>
+  requires std::is_same_v<internal_node_t, T> || std::is_same_v<leaf_node_t, T>
   update_internal_mapping_ret update_internal_mapping(
     op_context_t<node_key_t> c,
     depth_t depth,
     node_key_t laddr,
     paddr_t old_addr,
     paddr_t new_addr,
-    typename internal_node_t::base_ref nextent)
+    TCachedExtentRef<T> nextent)
   {
     LOG_PREFIX(FixedKVBtree::update_internal_mapping);
     SUBTRACET(
@@ -1226,6 +1222,7 @@ class FixedKVBtree {
     auto init_internal = [c, depth, begin, end,
                           parent_pos=std::move(parent_pos)]
                           (internal_node_t &node) {
+      using tree_root_linker_t = TreeRootLinker<RootBlock, internal_node_t>;
       assert(!node.is_pending());
       assert(!node.is_linked());
       node.range = fixed_kv_node_meta_t<node_key_t>{begin, end, depth};
@@ -1237,10 +1234,10 @@ class FixedKVBtree {
         auto root_block = c.cache.get_root_fast(c.trans);
         if (root_block->is_mutation_pending()) {
           auto &stable_root = (RootBlockRef&)*root_block->get_prior_instance();
-          link_phy_tree_root_node(stable_root, &node);
+          tree_root_linker_t::link_root(stable_root, &node);
         } else {
           assert(!root_block->is_pending());
-          link_phy_tree_root_node(root_block, &node);
+          tree_root_linker_t::link_root(root_block, &node);
         }
       }
     };
@@ -1311,6 +1308,7 @@ class FixedKVBtree {
     auto init_leaf = [c, begin, end,
                       parent_pos=std::move(parent_pos)]
                       (leaf_node_t &node) {
+      using tree_root_linker_t = TreeRootLinker<RootBlock, leaf_node_t>;
       assert(!node.is_pending());
       assert(!node.is_linked());
       node.range = fixed_kv_node_meta_t<node_key_t>{begin, end, 1};
@@ -1322,10 +1320,10 @@ class FixedKVBtree {
         auto root_block = c.cache.get_root_fast(c.trans);
         if (root_block->is_mutation_pending()) {
           auto &stable_root = (RootBlockRef&)*root_block->get_prior_instance();
-          link_phy_tree_root_node(stable_root, &node);
+          tree_root_linker_t::link_root(stable_root, &node);
         } else {
           assert(!root_block->is_pending());
-          link_phy_tree_root_node(root_block, &node);
+          tree_root_linker_t::link_root(root_block, &node);
         }
       }
     };
@@ -1493,7 +1491,8 @@ class FixedKVBtree {
       return seastar::now();
     };
 
-    auto v = parent->template get_child<internal_node_t>(c, node_iter);
+    auto v = parent->template get_child<internal_node_t>(
+      c.trans, c.cache, node_iter.get_offset(), node_iter.get_key());
     // checking the lba child must be atomic with creating
     // and linking the absent child
     if (v.has_child()) {
@@ -1527,7 +1526,7 @@ class FixedKVBtree {
       begin,
       end,
       std::make_optional<node_position_t<internal_node_t>>(
-        child_pos.template get_parent<internal_node_t>(),
+        child_pos.get_parent(),
         child_pos.get_pos())
     ).si_then([on_found=std::move(on_found)](InternalNodeRef node) {
       return on_found(node);
@@ -1563,7 +1562,8 @@ class FixedKVBtree {
       return seastar::now();
     };
 
-    auto v = parent->template get_child<leaf_node_t>(c, node_iter);
+    auto v = parent->template get_child<leaf_node_t>(
+      c.trans, c.cache, node_iter.get_offset(), node_iter.get_key());
     // checking the lba child must be atomic with creating
     // and linking the absent child
     if (v.has_child()) {
@@ -1597,7 +1597,7 @@ class FixedKVBtree {
       begin,
       end,
       std::make_optional<node_position_t<internal_node_t>>(
-        child_pos.template get_parent<internal_node_t>(),
+        child_pos.get_parent(),
         child_pos.get_pos())
     ).si_then([on_found=std::move(on_found)](LeafNodeRef node) {
       return on_found(node);
@@ -2118,7 +2118,8 @@ class FixedKVBtree {
       return seastar::now();
     };
 
-    auto v = parent_pos.node->template get_child<NodeType>(c, donor_iter);
+    auto v = parent_pos.node->template get_child<NodeType>(
+      c.trans, c.cache, donor_iter.get_offset(), donor_iter.get_key());
     // checking the lba child must be atomic with creating
     // and linking the absent child
     if (v.has_child()) {
@@ -2150,7 +2151,7 @@ class FixedKVBtree {
       begin,
       end,
       std::make_optional<node_position_t<internal_node_t>>(
-        child_pos.template get_parent<internal_node_t>(),
+        child_pos.get_parent(),
         child_pos.get_pos())
     ).si_then([do_merge=std::move(do_merge)](typename NodeType::Ref donor) {
       return do_merge(donor);