import quincy beta 17.1.0

[ceph.git] / ceph / src / crimson / os / seastore / onode_manager / staged-fltree / stages / item_iterator_stage.cc

diff --git a/ceph/src/crimson/os/seastore/onode_manager/staged-fltree/stages/item_iterator_stage.cc b/ceph/src/crimson/os/seastore/onode_manager/staged-fltree/stages/item_iterator_stage.cc
index 443c6cabdeb8a2e5b96ad2c46e0a344193aa1cb6..85c05e3cb12ae3e4901572b308f1fbca4616aab5 100644 (file)
--- a/ceph/src/crimson/os/seastore/onode_manager/staged-fltree/stages/item_iterator_stage.cc
+++ b/ceph/src/crimson/os/seastore/onode_manager/staged-fltree/stages/item_iterator_stage.cc
@@ -14,7 +14,8 @@ template <node_type_t NODE_TYPE>
 template <KeyT KT>
 memory_range_t ITER_T::insert_prefix(
     NodeExtentMutable& mut, const ITER_T& iter, const full_key_t<KT>& key,
-    bool is_end, node_offset_t size, const char* p_left_bound) {
+    bool is_end, node_offset_t size, const char* p_left_bound)
+{
   // 1. insert range
   char* p_insert;
   if (is_end) {
@@ -51,33 +52,49 @@ IP_TEMPLATE(node_type_t::INTERNAL, KeyT::HOBJ);
 
 template <node_type_t NODE_TYPE>
 void ITER_T::update_size(
-    NodeExtentMutable& mut, const ITER_T& iter, int change) {
+    NodeExtentMutable& mut, const ITER_T& iter, int change)
+{
   node_offset_t offset = iter.get_back_offset();
   int new_size = change + offset;
-  assert(new_size > 0 && new_size < NODE_BLOCK_SIZE);
+  assert(new_size > 0 && new_size < (int)mut.get_length());
   mut.copy_in_absolute(
       (void*)iter.get_item_range().p_end, node_offset_t(new_size));
 }
 
 template <node_type_t NODE_TYPE>
-node_offset_t ITER_T::trim_until(NodeExtentMutable&, const ITER_T& iter) {
+node_offset_t ITER_T::trim_until(NodeExtentMutable& mut, const ITER_T& iter)
+{
   assert(iter.index() != 0);
   size_t ret = iter.p_end() - iter.p_items_start;
-  assert(ret < NODE_BLOCK_SIZE);
+  assert(ret < mut.get_length());
   return ret;
 }
 
 template <node_type_t NODE_TYPE>
 node_offset_t ITER_T::trim_at(
-    NodeExtentMutable& mut, const ITER_T& iter, node_offset_t trimmed) {
+    NodeExtentMutable& mut, const ITER_T& iter, node_offset_t trimmed)
+{
   size_t trim_size = iter.p_start() - iter.p_items_start + trimmed;
-  assert(trim_size < NODE_BLOCK_SIZE);
+  assert(trim_size < mut.get_length());
   assert(iter.get_back_offset() > trimmed);
   node_offset_t new_offset = iter.get_back_offset() - trimmed;
   mut.copy_in_absolute((void*)iter.item_range.p_end, new_offset);
   return trim_size;
 }
 
+template <node_type_t NODE_TYPE>
+node_offset_t ITER_T::erase(
+    NodeExtentMutable& mut, const ITER_T& iter, const char* p_left_bound)
+{
+  node_offset_t erase_size = iter.p_end() - iter.p_start();
+  const char* p_shift_start = p_left_bound;
+  assert(p_left_bound <= iter.p_start());
+  extent_len_t shift_len = iter.p_start() - p_left_bound;
+  int shift_off = erase_size;
+  mut.shift_absolute(p_shift_start, shift_len, shift_off);
+  return erase_size;
+}
+
 #define ITER_TEMPLATE(NT) template class ITER_INST(NT)
 ITER_TEMPLATE(node_type_t::LEAF);
 ITER_TEMPLATE(node_type_t::INTERNAL);
@@ -86,7 +103,24 @@ ITER_TEMPLATE(node_type_t::INTERNAL);
 
 template <node_type_t NODE_TYPE>
 template <KeyT KT>
-bool APPEND_T::append(const ITER_T& src, index_t& items) {
+APPEND_T::Appender(NodeExtentMutable* p_mut,
+                   const item_iterator_t& iter,
+                   bool open) : p_mut{p_mut}
+{
+  assert(!iter.has_next());
+  if (open) {
+    p_append = const_cast<char*>(iter.get_key().p_start());
+    p_offset_while_open = const_cast<char*>(iter.item_range.p_end);
+  } else {
+    // XXX: this doesn't need to advance the iter to last
+    p_append = const_cast<char*>(iter.p_items_start);
+  }
+}
+
+template <node_type_t NODE_TYPE>
+template <KeyT KT>
+bool APPEND_T::append(const ITER_T& src, index_t& items)
+{
   auto p_end = src.p_end();
   bool append_till_end = false;
   if (is_valid_index(items)) {
@@ -130,7 +164,8 @@ bool APPEND_T::append(const ITER_T& src, index_t& items) {
 template <node_type_t NODE_TYPE>
 template <KeyT KT>
 std::tuple<NodeExtentMutable*, char*>
-APPEND_T::open_nxt(const key_get_type& partial_key) {
+APPEND_T::open_nxt(const key_get_type& partial_key)
+{
   p_append -= sizeof(node_offset_t);
   p_offset_while_open = p_append;
   ns_oid_view_t::append(*p_mut, partial_key, p_append);
@@ -140,7 +175,8 @@ APPEND_T::open_nxt(const key_get_type& partial_key) {
 template <node_type_t NODE_TYPE>
 template <KeyT KT>
 std::tuple<NodeExtentMutable*, char*>
-APPEND_T::open_nxt(const full_key_t<KT>& key) {
+APPEND_T::open_nxt(const full_key_t<KT>& key)
+{
   p_append -= sizeof(node_offset_t);
   p_offset_while_open = p_append;
   ns_oid_view_t::append<KT>(*p_mut, key, p_append);
@@ -149,7 +185,8 @@ APPEND_T::open_nxt(const full_key_t<KT>& key) {
 
 template <node_type_t NODE_TYPE>
 template <KeyT KT>
-void APPEND_T::wrap_nxt(char* _p_append) {
+void APPEND_T::wrap_nxt(char* _p_append)
+{
   assert(_p_append < p_append);
   p_mut->copy_in_absolute(
       p_offset_while_open, node_offset_t(p_offset_while_open - _p_append));