From: Zhang Song <zhangsong02@qianxin.com>
Date: Fri, 30 May 2025 09:45:39 +0000 (+0800)
Subject: crimson/os/seastore/OMapManager: only store the relative block offset to omap root... 
X-Git-Tag: v21.0.1~152^2~14
X-Git-Url: http://git-server-git.apps.pok.os.sepia.ceph.com/?a=commitdiff_plain;h=618d7e23325d440f4489bff02f9a5dc1c3b753aa;p=ceph.git

crimson/os/seastore/OMapManager: only store the relative block offset to omap root in OMapInnerNode

Signed-off-by: Zhang Song <zhangsong02@qianxin.com>
Signed-off-by: Xuehan Xu <xuxuehan@qianxin.com>
---

diff --git a/src/crimson/os/seastore/omap_manager/btree/btree_omap_manager.cc b/src/crimson/os/seastore/omap_manager/btree/btree_omap_manager.cc
index 4e623ec48a9..1422167f242 100644
--- a/src/crimson/os/seastore/omap_manager/btree/btree_omap_manager.cc
+++ b/src/crimson/os/seastore/omap_manager/btree/btree_omap_manager.cc
@@ -84,12 +84,12 @@ BtreeOMapManager::handle_root_split(
     nroot->insert_child_ptr(
       nroot->iter_begin().get_offset(),
       dynamic_cast<BaseChildNode<OMapInnerNode, std::string>*>(left.get()));
-    nroot->journal_inner_insert(nroot->iter_begin(), left->get_laddr(),
+    nroot->journal_inner_insert(nroot->iter_begin(), left->get_laddr().get_offset_blocks(),
                                 BEGIN_KEY, nroot->maybe_get_delta_buffer());
     nroot->insert_child_ptr(
       (nroot->iter_begin() + 1).get_offset(),
       dynamic_cast<BaseChildNode<OMapInnerNode, std::string>*>(right.get()));
-    nroot->journal_inner_insert(nroot->iter_begin() + 1, right->get_laddr(),
+    nroot->journal_inner_insert(nroot->iter_begin() + 1, right->get_laddr().get_offset_blocks(),
                                 pivot, nroot->maybe_get_delta_buffer());
     omap_root.update(nroot->get_laddr(), omap_root.get_depth() + 1, omap_root.hint,
       omap_root.get_type());
@@ -114,7 +114,7 @@ BtreeOMapManager::handle_root_merge(
   auto old_root = *(mresult.need_merge);
   auto iter = old_root->cast<OMapInnerNode>()->iter_begin();
   omap_root.update(
-    iter->get_val(),
+    omap_root.addr.with_offset_by_blocks(iter->get_val()),
     omap_root.depth -= 1,
     omap_root.hint,
     omap_root.get_type());
diff --git a/src/crimson/os/seastore/omap_manager/btree/btree_omap_manager.h b/src/crimson/os/seastore/omap_manager/btree/btree_omap_manager.h
index ae04a19f575..26b7b5cbcde 100644
--- a/src/crimson/os/seastore/omap_manager/btree/btree_omap_manager.h
+++ b/src/crimson/os/seastore/omap_manager/btree/btree_omap_manager.h
@@ -28,7 +28,7 @@ class BtreeOMapManager : public OMapManager {
   omap_context_t get_omap_context(
     Transaction &t, const omap_root_t &omap_root) {
     ceph_assert(omap_root.type < omap_type_t::NONE);
-    return omap_context_t{tm, t, omap_root.hint, omap_root.type};
+    return omap_context_t{tm, t, omap_root.hint, omap_root.type, omap_root.addr};
   }
 
   /* get_omap_root
diff --git a/src/crimson/os/seastore/omap_manager/btree/omap_btree_node.h b/src/crimson/os/seastore/omap_manager/btree/omap_btree_node.h
index 0f3ae3536d0..897e1116731 100644
--- a/src/crimson/os/seastore/omap_manager/btree/omap_btree_node.h
+++ b/src/crimson/os/seastore/omap_manager/btree/omap_btree_node.h
@@ -24,6 +24,7 @@ struct omap_context_t {
   Transaction &t;
   laddr_hint_t hint;
   omap_type_t type;
+  laddr_t root;
 };
 
 enum class mutation_status_t : uint8_t {
diff --git a/src/crimson/os/seastore/omap_manager/btree/omap_btree_node_impl.cc b/src/crimson/os/seastore/omap_manager/btree/omap_btree_node_impl.cc
index 5d053b7ded6..80c4666cbd0 100644
--- a/src/crimson/os/seastore/omap_manager/btree/omap_btree_node_impl.cc
+++ b/src/crimson/os/seastore/omap_manager/btree/omap_btree_node_impl.cc
@@ -18,7 +18,7 @@ namespace crimson::os::seastore::omap_manager {
 std::ostream &operator<<(std::ostream &out, const omap_inner_key_t &rhs)
 {
   return out << "omap_inner_key (" << rhs.key_off<< " - " << rhs.key_len
-             << " - " << rhs.laddr << ")";
+             << " - " << rhs.block_offset << ")";
 }
 
 std::ostream &operator<<(std::ostream &out, const omap_leaf_key_t &rhs)
@@ -78,14 +78,14 @@ OMapInnerNode::make_split_insert(
       left->insert_child_ptr(
 	liter.get_offset(),
 	dynamic_cast<base_child_t*>(node.get()));
-      left->journal_inner_insert(liter, node->get_laddr(), key,
+      left->journal_inner_insert(liter, node->get_laddr().get_offset_blocks(), key,
                                  left->maybe_get_delta_buffer());
     } else {  //right
       auto riter = right->iter_idx(iter.get_offset() - left->get_node_size());
       right->insert_child_ptr(
 	riter.get_offset(),
 	dynamic_cast<base_child_t*>(node.get()));
-      right->journal_inner_insert(riter, node->get_laddr(), key,
+      right->journal_inner_insert(riter, node->get_laddr().get_offset_blocks(), key,
                                   right->maybe_get_delta_buffer());
     }
     this->adjust_copy_src_dest_on_split(oc.t, *left, *right);
@@ -117,14 +117,14 @@ OMapInnerNode::handle_split(
   this->update_child_ptr(
     iter.get_offset(),
     dynamic_cast<base_child_t*>(left.get()));
-  journal_inner_update(iter, left->get_laddr(), maybe_get_delta_buffer());
+  journal_inner_update(iter, left->get_laddr().get_offset_blocks(), maybe_get_delta_buffer());
   bool overflow = extent_will_overflow(pivot.size(), std::nullopt);
   auto right_iter = iter + 1;
   if (!overflow) {
     this->insert_child_ptr(
       right_iter.get_offset(),
       dynamic_cast<base_child_t*>(right.get()));
-    journal_inner_insert(right_iter, right->get_laddr(), pivot,
+    journal_inner_insert(right_iter, right->get_laddr().get_offset_blocks(), pivot,
                          maybe_get_delta_buffer());
     return insert_ret(
            interruptible::ready_future_marker{},
@@ -415,7 +415,7 @@ OMapInnerNode::clear(omap_context_t oc)
   DEBUGT("this: {}", oc.t, *this);
   return trans_intr::do_for_each(iter_begin(), iter_end(),
     [oc, this](auto iter) {
-    auto laddr = iter->get_val();
+    auto laddr = oc.root.with_offset_by_blocks(iter->get_val());
     auto ndepth = get_meta().depth - 1;
     if (ndepth > 1) {
       return get_child_node(oc, iter
@@ -531,7 +531,7 @@ OMapInnerNode::do_merge(
       dynamic_cast<base_child_t*>(replacement.get()));
     journal_inner_update(
       liter,
-      replacement->get_laddr(),
+      replacement->get_laddr().get_offset_blocks(),
       maybe_get_delta_buffer());
     this->remove_child_ptr(riter.get_offset());
     journal_inner_remove(riter, maybe_get_delta_buffer());
@@ -619,7 +619,7 @@ OMapInnerNode::do_balance(
       dynamic_cast<base_child_t*>(replacement_l.get()));
     journal_inner_update(
       liter,
-      replacement_l->get_laddr(),
+      replacement_l->get_laddr().get_offset_blocks(),
       maybe_get_delta_buffer());
     bool overflow = extent_will_overflow(replacement_pivot.size(),
       std::nullopt);
@@ -630,7 +630,7 @@ OMapInnerNode::do_balance(
       journal_inner_remove(riter, maybe_get_delta_buffer());
       journal_inner_insert(
 	riter,
-	replacement_r->get_laddr(),
+	replacement_r->get_laddr().get_offset_blocks(),
 	replacement_pivot,
 	maybe_get_delta_buffer());
       std::vector<laddr_t> dec_laddrs{l->get_laddr(), r->get_laddr()};
@@ -1022,7 +1022,7 @@ OMapInnerNode::get_child_node(
 {
   assert(get_meta().depth > 1);
   child_pos_t<OMapInnerNode> child_pos(nullptr, 0);
-  auto laddr = child_pt->get_val();
+  auto laddr = oc.root.with_offset_by_blocks(child_pt->get_val());
   auto next = child_pt + 1;
   if (get_meta().depth == 2) {
     auto ret = this->get_child<OMapLeafNode>(
diff --git a/src/crimson/os/seastore/omap_manager/btree/omap_types.h b/src/crimson/os/seastore/omap_manager/btree/omap_types.h
index 723c6884053..53a7dd40b9b 100644
--- a/src/crimson/os/seastore/omap_manager/btree/omap_types.h
+++ b/src/crimson/os/seastore/omap_manager/btree/omap_types.h
@@ -46,23 +46,23 @@ struct omap_node_meta_le_t {
 struct omap_inner_key_t {
   uint16_t key_off = 0;
   uint16_t key_len = 0;
-  laddr_t laddr = L_ADDR_MIN;
+  laddr_block_offset_t block_offset = 0;
 
   omap_inner_key_t() = default;
-  omap_inner_key_t(uint16_t off, uint16_t len, laddr_t addr)
-  : key_off(off), key_len(len), laddr(addr) {}
+  omap_inner_key_t(uint16_t off, uint16_t len, laddr_block_offset_t offset)
+  : key_off(off), key_len(len), block_offset(offset) {}
 
   inline bool operator==(const omap_inner_key_t b) const {
-    return key_off == b.key_off && key_len == b.key_len && laddr == b.laddr;
+    return key_off == b.key_off && key_len == b.key_len && block_offset == b.block_offset;
   }
   inline bool operator!=(const omap_inner_key_t b) const {
-    return key_off != b.key_off || key_len != b.key_len || laddr != b.laddr;
+    return key_off != b.key_off || key_len != b.key_len || block_offset != b.block_offset;
   }
   DENC(omap_inner_key_t, v, p) {
     DENC_START(1, 1, p);
     denc(v.key_off, p);
     denc(v.key_len, p);
-    denc(v.laddr, p);
+    denc(v.block_offset, p);
     DENC_FINISH(p);
   }
 };
@@ -70,28 +70,28 @@ struct omap_inner_key_t {
 struct omap_inner_key_le_t {
   ceph_le16 key_off{0};
   ceph_le16 key_len{0};
-  laddr_le_t laddr{L_ADDR_MIN};
+  laddr_block_offset_le_t block_offset{0};
 
   omap_inner_key_le_t() = default;
   omap_inner_key_le_t(const omap_inner_key_le_t &) = default;
   explicit omap_inner_key_le_t(const omap_inner_key_t &key)
     : key_off(key.key_off),
       key_len(key.key_len),
-      laddr(key.laddr) {}
+      block_offset(key.block_offset) {}
 
   operator omap_inner_key_t() const {
-    return omap_inner_key_t{uint16_t(key_off), uint16_t(key_len), laddr_t(laddr)};
+    return omap_inner_key_t{uint16_t(key_off), uint16_t(key_len), laddr_block_offset_t(block_offset)};
   }
 
   omap_inner_key_le_t& operator=(omap_inner_key_t key) {
     key_off = key.key_off;
     key_len = key.key_len;
-    laddr = laddr_le_t(key.laddr);
+    block_offset = laddr_block_offset_le_t(key.block_offset);
     return *this;
   }
 
   inline bool operator==(const omap_inner_key_le_t b) const {
-    return key_off == b.key_off && key_len == b.key_len && laddr == b.laddr;
+    return key_off == b.key_off && key_len == b.key_len && block_offset == b.block_offset;
   }
 };
 
diff --git a/src/crimson/os/seastore/omap_manager/btree/string_kv_node_layout.h b/src/crimson/os/seastore/omap_manager/btree/string_kv_node_layout.h
index b4791ca37b4..77c62184f34 100644
--- a/src/crimson/os/seastore/omap_manager/btree/string_kv_node_layout.h
+++ b/src/crimson/os/seastore/omap_manager/btree/string_kv_node_layout.h
@@ -101,13 +101,13 @@ struct delta_inner_t {
     REMOVE,
   } op;
   std::string key;
-  laddr_t addr;
+  laddr_block_offset_t block_offset;
 
   DENC(delta_inner_t, v, p) {
     DENC_START(1, 1, p);
     denc(v.op, p);
     denc(v.key, p);
-    denc(v.addr, p);
+    denc(v.block_offset, p);
     DENC_FINISH(p);
   }
 
@@ -115,7 +115,7 @@ struct delta_inner_t {
   bool operator==(const delta_inner_t &rhs) const {
     return op == rhs.op &&
            key == rhs.key &&
-           addr == rhs.addr;
+           block_offset == rhs.block_offset;
   }
 };
 }
@@ -158,22 +158,22 @@ public:
   }
   void insert(
     const std::string &key,
-    laddr_t addr) {
+    laddr_block_offset_t block_offset) {
     buffer.push_back(
       delta_inner_t{
         delta_inner_t::op_t::INSERT,
         key,
-        addr
+        block_offset
       });
   }
   void update(
     const std::string &key,
-    laddr_t addr) {
+    laddr_block_offset_t block_offset) {
     buffer.push_back(
       delta_inner_t{
 	delta_inner_t::op_t::UPDATE,
 	key,
-	addr
+	block_offset
       });
   }
   void remove(const std::string &key) {
@@ -181,7 +181,7 @@ public:
       delta_inner_t{
 	delta_inner_t::op_t::REMOVE,
 	key,
-	L_ADDR_NULL
+	LADDR_BLOCK_OFFSET_NULL
       });
   }
 
@@ -460,8 +460,8 @@ public:
 	get_node_key().key_len);
     }
 
-    laddr_t get_val() const {
-      return get_node_key().laddr;
+    laddr_block_offset_t get_val() const {
+      return get_node_key().block_offset;
     }
 
     bool contains(std::string_view key) const {
@@ -480,28 +480,28 @@ public:
 public:
   void journal_inner_insert(
     const_iterator _iter,
-    const laddr_t laddr,
+    const laddr_block_offset_t block_offset,
     const std::string &key,
     delta_inner_buffer_t *recorder) {
     auto iter = iterator(this, _iter.index);
     if (recorder) {
       recorder->insert(
 	key,
-	laddr);
+	block_offset);
     }
-    inner_insert(iter, key, laddr);
+    inner_insert(iter, key, block_offset);
   }
 
   void journal_inner_update(
     const_iterator _iter,
-    const laddr_t laddr,
+    const laddr_block_offset_t block_offset,
     delta_inner_buffer_t *recorder) {
     auto iter = iterator(this, _iter.index);
     auto key = iter->get_key();
     if (recorder) {
-      recorder->update(key, laddr);
+      recorder->update(key, block_offset);
     }
-    inner_update(iter, laddr);
+    inner_update(iter, block_offset);
   }
 
   void journal_inner_remove(
@@ -856,7 +856,7 @@ private:
   void inner_insert(
     iterator iter,
     const std::string &key,
-    laddr_t val) {
+    laddr_block_offset_t val) {
     if (iter != iter_begin()) {
       assert((iter - 1)->get_key() < key);
     }
@@ -871,7 +871,7 @@ private:
 
     omap_inner_key_t nkey;
     nkey.key_len = key.size();
-    nkey.laddr = val;
+    nkey.block_offset = val;
     if (iter != iter_begin()) {
       auto pkey = (iter - 1).get_node_key();
       nkey.key_off = nkey.key_len + pkey.key_off;
@@ -886,10 +886,10 @@ private:
 
   void inner_update(
     iterator iter,
-    laddr_t addr) {
+    laddr_block_offset_t block_offset) {
     assert(iter != iter_end());
     auto node_key = iter->get_node_key();
-    node_key.laddr = addr;
+    node_key.block_offset = block_offset;
     iter->set_node_key(node_key);
   }
 
@@ -1574,13 +1574,13 @@ private:
 inline void delta_inner_t::replay(StringKVInnerNodeLayout &l) {
   switch (op) {
     case op_t::INSERT: {
-      l.inner_insert(l.string_lower_bound(key), key, addr);
+      l.inner_insert(l.string_lower_bound(key), key, block_offset);
       break;
     }
     case op_t::UPDATE: {
       auto iter = l.find_string_key(key);
       assert(iter != l.iter_end());
-      l.inner_update(iter, addr);
+      l.inner_update(iter, block_offset);
       break;
     }
     case op_t::REMOVE: {
diff --git a/src/crimson/os/seastore/seastore_types.h b/src/crimson/os/seastore/seastore_types.h
index 6cfd955e612..fb748367849 100644
--- a/src/crimson/os/seastore/seastore_types.h
+++ b/src/crimson/os/seastore/seastore_types.h
@@ -1108,6 +1108,11 @@ using laddr_pool_t = int64_t;
 // Note: this is the reversed version of the object hash
 using laddr_crush_hash_t = uint32_t;
 
+using laddr_block_offset_t = uint32_t;
+constexpr laddr_block_offset_t LADDR_BLOCK_OFFSET_NULL =
+    std::numeric_limits<uint32_t>::max();
+using laddr_block_offset_le_t = ceph_le32;
+
 // refer to doc/dev/crimson/seastore_laddr.rst
 class laddr_t {
 public:
@@ -1300,15 +1305,15 @@ public:
   loffset_t get_offset_bytes() const {
     return layout::BlockOffsetSpec::get<loffset_t>(value) << UNIT_SHIFT;
   }
-  loffset_t get_offset_blocks() const {
-    return layout::BlockOffsetSpec::get<loffset_t>(value);
+  laddr_block_offset_t get_offset_blocks() const {
+    return layout::BlockOffsetSpec::get<laddr_block_offset_t>(value);
   }
   void set_offset_by_bytes(loffset_t offset) {
     assert(p2align(uint64_t(offset), uint64_t(UNIT_SIZE)) == offset);
     offset >>= UNIT_SHIFT;
     layout::BlockOffsetSpec::set(value, offset);
   }
-  void set_offset_by_blocks(loffset_t offset) {
+  void set_offset_by_blocks(laddr_block_offset_t offset) {
     layout::BlockOffsetSpec::set(value, offset);
   }
   laddr_t with_offset_by_bytes(loffset_t offset) const {
@@ -1316,7 +1321,7 @@ public:
     ret.set_offset_by_bytes(offset);
     return ret;
   }
-  laddr_t with_offset_by_blocks(loffset_t offset) const {
+  laddr_t with_offset_by_blocks(laddr_block_offset_t offset) const {
     auto ret = *this;
     ret.set_offset_by_blocks(offset);
     return ret;