class BtreeBackrefMapping : public BackrefMapping {
public:
- BtreeBackrefMapping(op_context_t ctx)
- : BackrefMapping(ctx) {}
BtreeBackrefMapping(
op_context_t ctx,
BackrefLeafNodeRef parent,
namespace crimson::os::seastore {
-class BackrefMapping : public BtreeNodeMapping<paddr_t, laddr_t> {
+class BackrefMapping {
+ op_context_t ctx;
+ CachedExtentRef parent;
+ fixed_kv_node_meta_t<paddr_t> range;
+ laddr_t value;
+ extent_len_t len = 0;
+ uint16_t pos = std::numeric_limits<uint16_t>::max();
extent_types_t type;
public:
- BackrefMapping(op_context_t ctx)
- : BtreeNodeMapping(ctx) {}
- template <typename... T>
- BackrefMapping(extent_types_t type, T&&... t)
- : BtreeNodeMapping(std::forward<T>(t)...),
- type(type) {}
+ BackrefMapping(
+ extent_types_t type,
+ op_context_t ctx,
+ CachedExtentRef parent,
+ uint16_t pos,
+ laddr_t value,
+ extent_len_t len,
+ fixed_kv_node_meta_t<paddr_t> meta)
+ : ctx(ctx),
+ parent(parent),
+ range(meta),
+ value(value),
+ len(len),
+ pos(pos),
+ type(type)
+ {}
+
+ extent_len_t get_length() const {
+ ceph_assert(range.end > range.begin);
+ return len;
+ }
+
+ laddr_t get_val() const {
+ return value;
+ }
+
+ paddr_t get_key() const {
+ return range.begin;
+ }
+
extent_types_t get_type() const {
return type;
}
}
};
-template <typename key_t, typename val_t>
-class BtreeNodeMapping : public PhysicalNodeMapping<key_t, val_t> {
-protected:
- op_context_t ctx;
- /**
- * parent
- *
- * populated until link_extent is called to ensure cache residence
- * until add_pin is called.
- */
- CachedExtentRef parent;
-
- pladdr_t value;
- extent_len_t len = 0;
- fixed_kv_node_meta_t<key_t> range;
- uint16_t pos = std::numeric_limits<uint16_t>::max();
- fixed_kv_node_meta_t<key_t> _get_pin_range() const {
- return range;
- }
-
-public:
- using val_type = val_t;
- BtreeNodeMapping(op_context_t ctx) : ctx(ctx) {}
-
- BtreeNodeMapping(
- op_context_t ctx,
- CachedExtentRef parent,
- uint16_t pos,
- pladdr_t value,
- extent_len_t len,
- fixed_kv_node_meta_t<key_t> meta)
- : ctx(ctx),
- parent(parent),
- value(value),
- len(len),
- range(meta),
- pos(pos)
- {}
-
- CachedExtentRef get_parent() const final {
- return parent;
- }
-
- CachedExtentRef get_parent() {
- return parent;
- }
-
- uint16_t get_pos() const final {
- return pos;
- }
-
- extent_len_t get_length() const final {
- ceph_assert(range.end > range.begin);
- return len;
- }
-
- val_t get_val() const final {
- if constexpr (std::is_same_v<val_t, paddr_t>) {
- return value.get_paddr();
- } else {
- static_assert(std::is_same_v<val_t, laddr_t>);
- return value.get_laddr();
- }
- }
-
- key_t get_key() const override {
- return range.begin;
- }
-
- bool has_been_invalidated() const final {
- return parent->has_been_invalidated();
- }
-
- bool is_parent_viewable() const final {
- ceph_assert(parent);
- return parent->is_viewable_by_trans(ctx.trans).first;
- }
- bool is_parent_valid() const final {
- ceph_assert(parent);
- return parent->is_valid();
- }
-};
-
}
friend class crimson::os::seastore::SegmentedAllocator;
friend class crimson::os::seastore::TransactionManager;
friend class crimson::os::seastore::ExtentPlacementManager;
- template <typename, typename>
- friend class BtreeNodeMapping;
+ friend class LBAMapping;
friend class ::btree_lba_manager_test;
friend class ::lba_btree_test;
friend class ::btree_test_base;
uint64_t bytes = 0;
};
-template <typename key_t, typename>
-class PhysicalNodeMapping;
-
-template <typename key_t, typename val_t>
-using PhysicalNodeMappingRef = std::unique_ptr<PhysicalNodeMapping<key_t, val_t>>;
-
-template <typename key_t, typename val_t>
-class PhysicalNodeMapping {
-public:
- PhysicalNodeMapping() = default;
- PhysicalNodeMapping(const PhysicalNodeMapping&) = delete;
- virtual extent_len_t get_length() const = 0;
- virtual val_t get_val() const = 0;
- virtual key_t get_key() const = 0;
- virtual bool has_been_invalidated() const = 0;
- virtual CachedExtentRef get_parent() const = 0;
- virtual uint16_t get_pos() const = 0;
- virtual uint32_t get_checksum() const {
- ceph_abort("impossible");
- return 0;
- }
- virtual bool is_parent_viewable() const = 0;
- virtual bool is_parent_valid() const = 0;
- virtual bool parent_modified() const {
- ceph_abort("impossible");
- return false;
- };
-
- virtual void maybe_fix_pos() {
- ceph_abort("impossible");
- }
-
- virtual ~PhysicalNodeMapping() {}
-};
-
/**
* RetiredExtentPlaceholder
*
class LogicalCachedExtent;
-class LBAMapping : public BtreeNodeMapping<laddr_t, paddr_t> {
+class LBAMapping {
public:
LBAMapping(op_context_t ctx)
- : BtreeNodeMapping<laddr_t, paddr_t>(ctx) {}
- template <typename... T>
- LBAMapping(T&&... t)
- : BtreeNodeMapping<laddr_t, paddr_t>(std::forward<T>(t)...)
+ : ctx(ctx) {}
+ LBAMapping(
+ op_context_t ctx,
+ CachedExtentRef parent,
+ uint16_t pos,
+ pladdr_t value,
+ extent_len_t len,
+ fixed_kv_node_meta_t<laddr_t> meta)
+ : ctx(ctx),
+ parent(parent),
+ value(value),
+ len(len),
+ range(meta),
+ pos(pos)
{}
+ CachedExtentRef get_parent() {
+ return parent;
+ }
+
+ uint16_t get_pos() const {
+ return pos;
+ }
+
+ extent_len_t get_length() const {
+ ceph_assert(range.end > range.begin);
+ return len;
+ }
+
+ paddr_t get_val() const {
+ return value.get_paddr();
+ }
+
+ virtual laddr_t get_key() const {
+ return range.begin;
+ }
+
+ bool has_been_invalidated() const {
+ return parent->has_been_invalidated();
+ }
+
+ bool is_parent_viewable() const {
+ ceph_assert(parent);
+ return parent->is_viewable_by_trans(ctx.trans).first;
+ }
+
+ bool is_parent_valid() const {
+ ceph_assert(parent);
+ return parent->is_valid();
+ }
+
+ virtual void maybe_fix_pos() = 0;
+ virtual bool parent_modified() const = 0;
+ virtual uint32_t get_checksum() const = 0;
+
// An lba pin may be indirect, see comments in lba_manager/btree/btree_lba_manager.h
virtual bool is_indirect() const = 0;
virtual laddr_t get_intermediate_key() const = 0;
virtual ~LBAMapping() {}
protected:
virtual LBAMappingRef _duplicate(op_context_t) const = 0;
+
+ op_context_t ctx;
+ CachedExtentRef parent;
+
+ pladdr_t value;
+ extent_len_t len = 0;
+ fixed_kv_node_meta_t<laddr_t> range;
+ uint16_t pos = std::numeric_limits<uint16_t>::max();
+
std::optional<child_pos_t<
lba_manager::btree::LBALeafNode>> child_pos = std::nullopt;
};