onode_manager/staged-fltree/node.cc
onode_manager/staged-fltree/node_extent_manager.cc
onode_manager/staged-fltree/node_extent_manager/seastore.cc
- onode_manager/staged-fltree/node_extent_mutable.cc
onode_manager/staged-fltree/node_impl.cc
onode_manager/staged-fltree/stages/item_iterator_stage.cc
onode_manager/staged-fltree/stages/key_layout.cc
virtual node_type_t node_type() const = 0;
virtual field_type_t field_type() const = 0;
virtual void apply_delta(ceph::bufferlist::const_iterator&,
- NodeExtentMutable&) = 0;
+ NodeExtentMutable&,
+ laddr_t) = 0;
protected:
DeltaRecorder() = default;
node_type_t node_type() const override { return NODE_TYPE; }
field_type_t field_type() const override { return FIELD_TYPE; }
void apply_delta(ceph::bufferlist::const_iterator& delta,
- NodeExtentMutable& node) override {
+ NodeExtentMutable& node,
+ laddr_t node_laddr) override {
assert(is_empty());
node_stage_t stage(reinterpret_cast<const FieldType*>(node.get_read()));
op_t op;
}
default:
logger().error("OTree::Extent::Replay: got unknown op {} when replay {:#x}",
- op, node.get_laddr());
+ op, node_laddr);
ceph_abort();
}
} catch (buffer::error& e) {
logger().error("OTree::Extent::Replay: got decode error {} when replay {:#x}",
- e, node.get_laddr());
+ e, node_laddr);
ceph_abort();
}
}
NodeExtent(T&&... t) : LogicalCachedExtent(std::forward<T>(t)...) {}
NodeExtentMutable do_get_mutable() {
- return NodeExtentMutable(*this);
+ assert(is_pending() || // during mutation
+ is_clean()); // during replay
+ return NodeExtentMutable(get_bptr().c_str(), get_length());
}
/**
* - CacheExtent::get_delta() -> ceph::bufferlist
* - LogicalCachedExtent::apply_delta(const ceph::bufferlist) -> void
*/
-
- private:
- friend class NodeExtentMutable;
};
using crimson::os::seastore::TransactionManager;
auto node = do_get_mutable();
auto p = bl.cbegin();
while (p != bl.end()) {
- recorder->apply_delta(p, node);
+ recorder->apply_delta(p, node, get_laddr());
}
}
auto bl = recorder->get_delta();
assert(bl.length());
auto p = bl.cbegin();
- recorder->apply_delta(p, mut);
+ recorder->apply_delta(p, mut, 0u);
assert(p == bl.end());
auto cmp = std::memcmp(get_read(), replayed_extent->get_read(), get_length());
ceph_assert(cmp == 0 && "replay mismatch!");
+++ /dev/null
-// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:nil -*-
-// vim: ts=8 sw=2 smarttab
-
-#include "node_extent_mutable.h"
-#include "node_extent_manager.h"
-
-namespace crimson::os::seastore::onode {
-
-NodeExtentMutable::NodeExtentMutable(NodeExtent& extent)
- : extent{extent} {
- assert(extent.is_pending() || // during mutation
- extent.is_clean()); // during replay
-}
-
-const char* NodeExtentMutable::get_read() const {
- assert(extent.is_pending() || // during mutation
- extent.is_clean()); // during replay
- return extent.get_bptr().c_str();
-}
-
-char* NodeExtentMutable::get_write() {
- assert(extent.is_pending() || // during mutation
- extent.is_clean()); // during replay
- return extent.get_bptr().c_str();
-}
-
-extent_len_t NodeExtentMutable::get_length() const {
- return extent.get_length();
-}
-
-laddr_t NodeExtentMutable::get_laddr() const {
- return extent.get_laddr();
-}
-
-const char* NodeExtentMutable::buf_upper_bound() const {
- return get_read() + get_length();
-}
-
-}
namespace crimson::os::seastore::onode {
-class NodeExtent;
-
/**
* NodeExtentMutable
*
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>
}
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);
}
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 { return length; }
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;
friend class NodeExtent;
};