Merge pull request ceph#60654 from cyx1231st/wip-seastore-fine-grained-cache

crimson/os/seastore: support partial read for data extents

Reviewed-by: Xuehan Xu <[email protected]>
Reviewed-by: Matan Breizman <[email protected]>

Author: cyx1231st

src/common/options/crimson.yaml.in

@@ -105,8 +105,8 @@ options:
 - name: seastore_max_data_allocation_size
   type: size
   level: advanced
-  desc: Max size in bytes that an extent can be
-  default: 32_K
+  desc: Max size in bytes that an extent can be, 0 to disable
+  default: 0
 - name: seastore_cache_lru_size
   type: size
   level: advanced

src/crimson/common/fixed_kv_node_layout.h

@@ -360,11 +360,16 @@ class FixedKVNodeLayout {
   }
 
 
-  FixedKVNodeLayout(char *buf) :
-    buf(buf) {}
+  FixedKVNodeLayout() : buf(nullptr) {}
 
   virtual ~FixedKVNodeLayout() = default;
 
+  void set_layout_buf(char *_buf) {
+    assert(buf == nullptr);
+    assert(_buf != nullptr);
+    buf = _buf;
+  }
+
   const_iterator begin() const {
     return const_iterator(
       this,

src/crimson/os/seastore/CMakeLists.txt

@@ -4,6 +4,7 @@ set(crimson_seastore_srcs
   segment_manager.cc
   segment_manager/ephemeral.cc
   segment_manager/block.cc
+  transaction_interruptor.cc
   transaction_manager.cc
   transaction.cc
   cache.cc

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

@@ -28,28 +28,22 @@ const get_phy_tree_root_node_ret get_phy_tree_root_node<
     ceph_assert(backref_root->is_initial_pending()
       == root_block->is_pending());
     return {true,
-	    trans_intr::make_interruptible(
-	      c.cache.get_extent_viewable_by_trans(c.trans, backref_root))};
+            c.cache.get_extent_viewable_by_trans(c.trans, backref_root)};
   } else if (root_block->is_pending()) {
     auto &prior = static_cast<RootBlock&>(*root_block->get_prior_instance());
     backref_root = prior.backref_root_node;
     if (backref_root) {
       return {true,
-	      trans_intr::make_interruptible(
-		c.cache.get_extent_viewable_by_trans(c.trans, backref_root))};
+              c.cache.get_extent_viewable_by_trans(c.trans, backref_root)};
     } else {
       c.cache.account_absent_access(c.trans.get_src());
       return {false,
-	      trans_intr::make_interruptible(
-		Cache::get_extent_ertr::make_ready_future<
-		  CachedExtentRef>())};
+              Cache::get_extent_iertr::make_ready_future<CachedExtentRef>()};
     }
   } else {
     c.cache.account_absent_access(c.trans.get_src());
     return {false,
-	    trans_intr::make_interruptible(
-	      Cache::get_extent_ertr::make_ready_future<
-		CachedExtentRef>())};
+            Cache::get_extent_iertr::make_ready_future<CachedExtentRef>()};
   }
 }
 

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

@@ -32,10 +32,6 @@ inline ChildableCachedExtent* get_reserved_ptr() {
 template <typename T>
 phy_tree_root_t& get_phy_tree_root(root_t& r);
 
-using get_child_iertr =
-  ::crimson::interruptible::interruptible_errorator<
-    typename trans_intr::condition,
-    get_child_ertr>;
 using get_phy_tree_root_node_ret =
   std::pair<bool, get_child_iertr::future<CachedExtentRef>>;
 
@@ -1501,7 +1497,7 @@ class FixedKVBtree {
     // checking the lba child must be atomic with creating
     // and linking the absent child
     if (v.has_child()) {
-      return trans_intr::make_interruptible(std::move(v.get_child_fut())
+      return std::move(v.get_child_fut()
       ).si_then([on_found=std::move(on_found), node_iter, c,
                 parent_entry](auto child) {
         LOG_PREFIX(FixedKVBtree::lookup_internal_level);
@@ -1571,7 +1567,7 @@ class FixedKVBtree {
     // checking the lba child must be atomic with creating
     // and linking the absent child
     if (v.has_child()) {
-      return trans_intr::make_interruptible(std::move(v.get_child_fut())
+      return std::move(v.get_child_fut()
       ).si_then([on_found=std::move(on_found), node_iter, c,
                 parent_entry](auto child) {
         LOG_PREFIX(FixedKVBtree::lookup_leaf);
@@ -2126,7 +2122,7 @@ class FixedKVBtree {
     // checking the lba child must be atomic with creating
     // and linking the absent child
     if (v.has_child()) {
-      return trans_intr::make_interruptible(std::move(v.get_child_fut())
+      return std::move(v.get_child_fut()
       ).si_then([do_merge=std::move(do_merge), &pos,
                 donor_iter, donor_is_left, c, parent_pos](auto child) {
         LOG_PREFIX(FixedKVBtree::merge_level);

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

@@ -165,6 +165,11 @@ struct FixedKVNode : ChildableCachedExtent {
     : ChildableCachedExtent(std::move(ptr)),
       children(capacity, nullptr),
       capacity(capacity) {}
+  // Must be identical with FixedKVNode(capacity, ptr) after on_fully_loaded()
+  explicit FixedKVNode(uint16_t capacity, extent_len_t length)
+    : ChildableCachedExtent(length),
+      children(capacity, nullptr),
+      capacity(capacity) {}
   FixedKVNode(const FixedKVNode &rhs)
     : ChildableCachedExtent(rhs),
       range(rhs.range),
@@ -708,12 +713,17 @@ struct FixedKVInternalNode
     node_size,
     node_type_t>;
 
-  FixedKVInternalNode(ceph::bufferptr &&ptr)
-    : FixedKVNode<NODE_KEY>(CAPACITY, std::move(ptr)),
-      node_layout_t(this->get_bptr().c_str()) {}
+  explicit FixedKVInternalNode(ceph::bufferptr &&ptr)
+    : FixedKVNode<NODE_KEY>(CAPACITY, std::move(ptr)) {
+    this->set_layout_buf(this->get_bptr().c_str());
+  }
+  // Must be identical with FixedKVInternalNode(ptr) after on_fully_loaded()
+  explicit FixedKVInternalNode(extent_len_t length)
+    : FixedKVNode<NODE_KEY>(CAPACITY, length) {}
   FixedKVInternalNode(const FixedKVInternalNode &rhs)
-    : FixedKVNode<NODE_KEY>(rhs),
-      node_layout_t(this->get_bptr().c_str()) {}
+    : FixedKVNode<NODE_KEY>(rhs) {
+    this->set_layout_buf(this->get_bptr().c_str());
+  }
 
   bool have_children() const final {
     return true;
@@ -985,6 +995,10 @@ struct FixedKVInternalNode
       pivot);
   }
 
+  void on_fully_loaded() final {
+    this->set_layout_buf(this->get_bptr().c_str());
+  }
+
   /**
    * Internal relative addresses on read or in memory prior to commit
    * are either record or block relative depending on whether this
@@ -994,8 +1008,7 @@ struct FixedKVInternalNode
    * resolve_relative_addrs fixes up relative internal references
    * based on base.
    */
-  void resolve_relative_addrs(paddr_t base)
-  {
+  void resolve_relative_addrs(paddr_t base) final {
     LOG_PREFIX(FixedKVInternalNode::resolve_relative_addrs);
     for (auto i: *this) {
       if (i->get_val().is_relative()) {
@@ -1122,13 +1135,18 @@ struct FixedKVLeafNode
     node_type_t,
     has_children>;
   using base_t = FixedKVNode<NODE_KEY>;
-  FixedKVLeafNode(ceph::bufferptr &&ptr)
-    : FixedKVNode<NODE_KEY>(has_children ? CAPACITY : 0, std::move(ptr)),
-      node_layout_t(this->get_bptr().c_str()) {}
+  explicit FixedKVLeafNode(ceph::bufferptr &&ptr)
+    : FixedKVNode<NODE_KEY>(has_children ? CAPACITY : 0, std::move(ptr)) {
+    this->set_layout_buf(this->get_bptr().c_str());
+  }
+  // Must be identical with FixedKVLeafNode(ptr) after on_fully_loaded()
+  explicit FixedKVLeafNode(extent_len_t length)
+    : FixedKVNode<NODE_KEY>(has_children ? CAPACITY : 0, length) {}
   FixedKVLeafNode(const FixedKVLeafNode &rhs)
     : FixedKVNode<NODE_KEY>(rhs),
-      node_layout_t(this->get_bptr().c_str()),
-      modifications(rhs.modifications) {}
+      modifications(rhs.modifications) {
+    this->set_layout_buf(this->get_bptr().c_str());
+  }
 
   static constexpr bool do_has_children = has_children;
   // for the stable extent, modifications is always 0;
@@ -1235,6 +1253,10 @@ struct FixedKVLeafNode
     }
   }
 
+  void on_fully_loaded() final {
+    this->set_layout_buf(this->get_bptr().c_str());
+  }
+
   void prepare_commit() final {
     if constexpr (has_children) {
       if (this->is_initial_pending()) {