import quincy beta 17.1.0

[ceph.git] / ceph / src / crimson / os / seastore / onode_manager / staged-fltree / node_extent_mutable.h

diff --git a/ceph/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_mutable.h b/ceph/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_mutable.h
index 52f10a013003093d786ca3a5b90a7df96dfd428b..6f92ca9edf389420d12ab259acde5b745b6d9177 100644 (file)
--- a/ceph/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_mutable.h
+++ b/ceph/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_mutable.h
@@ -9,8 +9,6 @@
 
 namespace crimson::os::seastore::onode {
 
-class NodeExtent;
-
 /**
  * NodeExtentMutable
  *
@@ -21,8 +19,7 @@ class NodeExtent;
 class NodeExtentMutable {
  public:
   void copy_in_absolute(void* dst, const void* src, extent_len_t len) {
-    assert((char*)dst >= get_write());
-    assert((char*)dst + len <= buf_upper_bound());
+    assert(is_safe(dst, len));
     std::memcpy(dst, src, len);
   }
   template <typename T>
@@ -44,11 +41,9 @@ class NodeExtentMutable {
   }
 
   void shift_absolute(const void* src, extent_len_t len, int offset) {
-    assert((const char*)src >= get_write());
-    assert((const char*)src + len <= buf_upper_bound());
+    assert(is_safe(src, len));
     char* to = (char*)src + offset;
-    assert(to >= get_write());
-    assert(to + len <= buf_upper_bound());
+    assert(is_safe(to, len));
     if (len != 0) {
       std::memmove(to, src, len);
     }
@@ -57,22 +52,60 @@ class NodeExtentMutable {
     shift_absolute(get_write() + src_offset, len, offset);
   }
 
+  void set_absolute(void* dst, int value, extent_len_t len) {
+    assert(is_safe(dst, len));
+    std::memset(dst, value, len);
+  }
+  void set_relative(extent_len_t dst_offset, int value, extent_len_t len) {
+    auto dst = get_write() + dst_offset;
+    set_absolute(dst, value, len);
+  }
+
   template <typename T>
   void validate_inplace_update(const T& updated) {
-    assert((const char*)&updated >= get_write());
-    assert((const char*)&updated + sizeof(T) <= buf_upper_bound());
+    assert(is_safe(&updated, sizeof(T)));
   }
 
-  const char* get_read() const;
-  char* get_write();
-  extent_len_t get_length() const;
-  laddr_t get_laddr() const;
+  const char* get_read() const { return p_start; }
+  char* get_write() { return p_start; }
+  extent_len_t get_length() const {
+#ifndef NDEBUG
+    if (node_offset == 0) {
+      assert(is_valid_node_size(length));
+    }
+#endif
+    return length;
+  }
+  node_offset_t get_node_offset() const { return node_offset; }
+
+  NodeExtentMutable get_mutable_absolute(const void* dst, node_offset_t len) const {
+    assert(node_offset == 0);
+    assert(is_safe(dst, len));
+    assert((const char*)dst != get_read());
+    auto ret = *this;
+    node_offset_t offset = (const char*)dst - get_read();
+    assert(offset != 0);
+    ret.p_start += offset;
+    ret.length = len;
+    ret.node_offset = offset;
+    return ret;
+  }
+  NodeExtentMutable get_mutable_relative(
+      node_offset_t offset, node_offset_t len) const {
+    return get_mutable_absolute(get_read() + offset, len);
+  }
 
  private:
-  explicit NodeExtentMutable(NodeExtent&);
-  const char* buf_upper_bound() const;
+  NodeExtentMutable(char* p_start, extent_len_t length)
+    : p_start{p_start}, length{length} {}
+  bool is_safe(const void* src, extent_len_t len) const {
+    return ((const char*)src >= p_start) &&
+           ((const char*)src + len <= p_start + length);
+  }
 
-  NodeExtent& extent;
+  char* p_start;
+  extent_len_t length;
+  node_offset_t node_offset = 0;
 
   friend class NodeExtent;
 };