From 1601345824dcfe9e0c1c6f9ba7335654dcb3a723 Mon Sep 17 00:00:00 2001 From: myoungwon oh Date: Wed, 3 Nov 2021 16:27:03 +0900 Subject: [PATCH] seastore: generalize paddr_t Due to necessity to support both segment and rbm addrs, paddr_t needs to be generlized. To do so, this commits introduces seg_paddr_t--- seg_paddr_t inherits paddr_t, and deals with common_addr according to the semantic of segment. Signed-off-by: Myoungwon Oh --- .../os/seastore/extent_placement_manager.h | 2 +- src/crimson/os/seastore/extent_reader.cc | 20 +- src/crimson/os/seastore/extent_reader.h | 4 +- src/crimson/os/seastore/journal.cc | 16 +- src/crimson/os/seastore/journal.h | 3 +- src/crimson/os/seastore/seastore_types.cc | 44 ++- src/crimson/os/seastore/seastore_types.h | 363 ++++++++++++------ src/crimson/os/seastore/segment_cleaner.cc | 2 +- src/crimson/os/seastore/segment_cleaner.h | 41 +- .../os/seastore/segment_manager/block.cc | 23 +- .../os/seastore/segment_manager/block.h | 5 +- .../os/seastore/segment_manager/ephemeral.cc | 21 +- .../os/seastore/segment_manager/ephemeral.h | 4 +- src/crimson/os/seastore/transaction_manager.h | 2 +- .../seastore/test_randomblock_manager.cc | 8 +- .../crimson/seastore/test_seastore_cache.cc | 16 +- .../crimson/seastore/test_seastore_journal.cc | 8 +- .../seastore/test_transaction_manager.cc | 4 +- 18 files changed, 372 insertions(+), 214 deletions(-) diff --git a/src/crimson/os/seastore/extent_placement_manager.h b/src/crimson/os/seastore/extent_placement_manager.h index a691f036ee4..0b040d72f76 100644 --- a/src/crimson/os/seastore/extent_placement_manager.h +++ b/src/crimson/os/seastore/extent_placement_manager.h @@ -65,7 +65,7 @@ public: segment_off_t extent_offset = base + rsize.mdlength; for (auto& extent : extents) { extent.set_ool_paddr( - {segment, extent_offset}); + paddr_t::make_seg_paddr(segment, extent_offset)); extent_offset += extent.get_bptr().length(); } assert(extent_offset == (segment_off_t)(base + rsize.mdlength + rsize.dlength)); diff --git a/src/crimson/os/seastore/extent_reader.cc b/src/crimson/os/seastore/extent_reader.cc index a3dca456bf5..18b5da676d6 100644 --- a/src/crimson/os/seastore/extent_reader.cc +++ b/src/crimson/os/seastore/extent_reader.cc @@ -18,7 +18,7 @@ ExtentReader::read_segment_header(segment_id_t segment) { auto& segment_manager = *segment_managers[segment.device_id()]; return segment_manager.read( - paddr_t{segment, 0}, + paddr_t::make_seg_paddr(segment, 0), segment_manager.get_block_size() ).handle_error( read_segment_header_ertr::pass_further{}, @@ -91,7 +91,9 @@ ExtentReader::scan_extents_ret ExtentReader::scan_extents( paddr_t extent_offset = base.add_offset(header.mdlength); for (const auto &i : *infos) { extents->emplace_back(extent_offset, i); - extent_offset.offset += i.len; + auto& seg_addr = extent_offset.as_seg_paddr(); + seg_addr.set_segment_off( + seg_addr.get_segment_off() + i.len); } return scan_extents_ertr::now(); }), @@ -228,9 +230,11 @@ ExtentReader::read_validate_record_metadata( paddr_t start, segment_nonce_t nonce) { - auto& segment_manager = *segment_managers[start.segment.device_id()]; + auto& seg_addr = start.as_seg_paddr(); + auto& segment_manager = *segment_managers[seg_addr.get_segment_id().device_id()]; auto block_size = segment_manager.get_block_size(); - if (start.offset + block_size > (int64_t)segment_manager.get_segment_size()) { + if (seg_addr.get_segment_off() + block_size > + (int64_t)segment_manager.get_segment_size()) { return read_validate_record_metadata_ret( read_validate_record_metadata_ertr::ready_future_marker{}, std::nullopt); @@ -257,13 +261,15 @@ ExtentReader::read_validate_record_metadata( read_validate_record_metadata_ertr::ready_future_marker{}, std::nullopt); } + auto& seg_addr = start.as_seg_paddr(); if (header.mdlength > (extent_len_t)block_size) { - if (start.offset + header.mdlength > + if (seg_addr.get_segment_off() + header.mdlength > (int64_t)segment_manager.get_segment_size()) { return crimson::ct_error::input_output_error::make(); } return segment_manager.read( - {start.segment, start.offset + (segment_off_t)block_size}, + paddr_t::make_seg_paddr(seg_addr.get_segment_id(), + seg_addr.get_segment_off() + (segment_off_t)block_size), header.mdlength - block_size).safe_then( [header=std::move(header), bl=std::move(bl)]( auto &&bptail) mutable { @@ -317,7 +323,7 @@ ExtentReader::read_validate_data( paddr_t record_base, const record_header_t &header) { - auto& segment_manager = *segment_managers[record_base.segment.device_id()]; + auto& segment_manager = *segment_managers[record_base.get_device_id()]; return segment_manager.read( record_base.add_offset(header.mdlength), header.dlength diff --git a/src/crimson/os/seastore/extent_reader.h b/src/crimson/os/seastore/extent_reader.h index a3f1dd53a68..e0d66495af5 100644 --- a/src/crimson/os/seastore/extent_reader.h +++ b/src/crimson/os/seastore/extent_reader.h @@ -78,8 +78,8 @@ public: paddr_t addr, size_t len, ceph::bufferptr &out) { - assert(segment_managers[addr.segment.device_id()]); - return segment_managers[addr.segment.device_id()]->read(addr, len, out); + assert(segment_managers[addr.get_device_id()]); + return segment_managers[addr.get_device_id()]->read(addr, len, out); } private: diff --git a/src/crimson/os/seastore/journal.cc b/src/crimson/os/seastore/journal.cc index 408acf27741..90bf37dcd1e 100644 --- a/src/crimson/os/seastore/journal.cc +++ b/src/crimson/os/seastore/journal.cc @@ -108,7 +108,8 @@ Journal::prep_replay_segments( segments.begin(), segments.end(), [&replay_from](const auto &seg) -> bool { - return seg.first == replay_from.segment; + auto& seg_addr = replay_from.as_seg_paddr(); + return seg.first == seg_addr.get_segment_id(); }); if (from->second.journal_segment_seq != journal_tail.segment_seq) { logger().error( @@ -118,9 +119,9 @@ Journal::prep_replay_segments( assert(0 == "invalid"); } } else { - replay_from = paddr_t{ + replay_from = paddr_t::make_seg_paddr( from->first, - (segment_off_t)journal_segment_manager.get_block_size()}; + (segment_off_t)journal_segment_manager.get_block_size()); } auto ret = replay_segments_t(segments.end() - from); std::transform( @@ -128,9 +129,9 @@ Journal::prep_replay_segments( [this](const auto &p) { auto ret = journal_seq_t{ p.second.journal_segment_seq, - paddr_t{ + paddr_t::make_seg_paddr( p.first, - (segment_off_t)journal_segment_manager.get_block_size()}}; + (segment_off_t)journal_segment_manager.get_block_size())}; logger().debug( "Journal::prep_replay_segments: replaying from {}", ret); @@ -202,8 +203,9 @@ Journal::replay_segment( * Note, this comparison exploits the fact that * SEGMENT_SEQ_NULL is a large number. */ + auto& seg_addr = delta.paddr.as_seg_paddr(); if (delta.paddr != P_ADDR_NULL && - (segment_provider->get_seq(delta.paddr.segment) > + (segment_provider->get_seq(seg_addr.get_segment_id()) > seq.segment_seq)) { return replay_ertr::now(); } else { @@ -359,7 +361,7 @@ Journal::JournalSegmentManager::write(ceph::bufferlist to_write) logger().debug( "JournalSegmentManager::write: write_start {} => {}, length={}", write_start_seq, - write_start_seq.offset.offset + write_length, + write_start_seq.offset.as_seg_paddr().get_segment_off() + write_length, write_length); assert(write_length > 0); assert((write_length % segment_manager.get_block_size()) == 0); diff --git a/src/crimson/os/seastore/journal.h b/src/crimson/os/seastore/journal.h index dec7c89ab54..a8bf5372f05 100644 --- a/src/crimson/os/seastore/journal.h +++ b/src/crimson/os/seastore/journal.h @@ -202,7 +202,8 @@ private: assert(current_journal_segment); return journal_seq_t{ get_segment_seq(), - {current_journal_segment->get_segment_id(), written_to} + paddr_t::make_seg_paddr(current_journal_segment->get_segment_id(), + written_to) }; } diff --git a/src/crimson/os/seastore/seastore_types.cc b/src/crimson/os/seastore/seastore_types.cc index cafe6fe6a8d..6f77b3f1f8e 100644 --- a/src/crimson/os/seastore/seastore_types.cc +++ b/src/crimson/os/seastore/seastore_types.cc @@ -9,16 +9,8 @@ std::ostream &segment_to_stream(std::ostream &out, const segment_id_t &t) { if (t == NULL_SEG_ID) return out << "NULL_SEG"; - else if (t == BLOCK_REL_SEG_ID) - return out << "BLOCK_REL_SEG"; - else if (t == RECORD_REL_SEG_ID) - return out << "RECORD_REL_SEG"; - else if (t == ZERO_SEG_ID) - return out << "ZERO_SEG"; else if (t == FAKE_SEG_ID) return out << "FAKE_SEG"; - else if (t == DELAYED_TEMP_SEG_ID) - return out << "DELAYED_TEMP_SEG"; else return out << t; } @@ -40,9 +32,24 @@ std::ostream &operator<<(std::ostream &out, const segment_id_t& segment) std::ostream &operator<<(std::ostream &out, const paddr_t &rhs) { out << "paddr_t<"; - segment_to_stream(out, rhs.segment); - out << ", "; - offset_to_stream(out, rhs.offset); + if (rhs == P_ADDR_NULL) { + out << "NULL_PADDR"; + } else if (rhs == P_ADDR_MIN) { + out << "MIN_PADDR"; + } else if (rhs.is_block_relative()) { + out << "BLOCK_REG"; + } else if (rhs.is_record_relative()) { + out << "RECORD_REG"; + } else if (rhs.get_device_id() == DEVICE_ID_DELAYED) { + out << "DELAYED_TEMP"; + } else if (rhs.get_addr_type() == addr_types_t::SEGMENT) { + const seg_paddr_t& s = rhs.as_seg_paddr(); + segment_to_stream(out, s.get_segment_id()); + out << ", "; + offset_to_stream(out, s.get_segment_off()); + } else { + out << "INVALID"; + } return out << ">"; } @@ -239,20 +246,21 @@ std::string device_type_to_string(device_type_t dtype) { paddr_t convert_blk_paddr_to_paddr(blk_paddr_t addr, size_t block_size, uint32_t blocks_per_segment, device_id_t d_id) { - paddr_t paddr; - paddr.segment = segment_id_t { + segment_id_t id = segment_id_t { d_id, - (uint32_t)(addr / (block_size * blocks_per_segment)) + (device_segment_id_t)(addr / (block_size * blocks_per_segment)) }; - paddr.offset = addr % (block_size * blocks_per_segment); - return paddr; + segment_off_t off = addr % (block_size * blocks_per_segment); + return paddr_t::make_seg_paddr(id, off); } blk_paddr_t convert_paddr_to_blk_paddr(paddr_t addr, size_t block_size, uint32_t blocks_per_segment) { - return (blk_paddr_t)(addr.segment.device_segment_id() * - (block_size * blocks_per_segment) + addr.offset); + seg_paddr_t& s = addr.as_seg_paddr(); + return (blk_paddr_t)(s.get_segment_id().device_segment_id() * + (block_size * blocks_per_segment) + s.get_segment_off()); } + } diff --git a/src/crimson/os/seastore/seastore_types.h b/src/crimson/os/seastore/seastore_types.h index 8ce7e8d77b0..b8275cda4a0 100644 --- a/src/crimson/os/seastore/seastore_types.h +++ b/src/crimson/os/seastore/seastore_types.h @@ -39,15 +39,30 @@ struct seastore_meta_t { // identifies a specific physical device within seastore using device_id_t = uint8_t; +constexpr uint16_t SEGMENT_ID_LEN_BITS = 24; + // order of device_id_t -constexpr uint16_t DEVICE_ID_LEN_BITS = 4; +constexpr uint16_t DEVICE_ID_LEN_BITS = 8; -// maximum number of devices supported -constexpr uint16_t DEVICE_ID_MAX = (1 << DEVICE_ID_LEN_BITS); +// 1 bit to identify address type // segment ids without a device id encapsulated using device_segment_id_t = uint32_t; +constexpr device_id_t DEVICE_ID_MAX = + (std::numeric_limits::max() >> + (std::numeric_limits::digits - DEVICE_ID_LEN_BITS + 1)); +constexpr device_id_t DEVICE_ID_RECORD_RELATIVE = DEVICE_ID_MAX - 1; +constexpr device_id_t DEVICE_ID_BLOCK_RELATIVE = DEVICE_ID_MAX - 2; +constexpr device_id_t DEVICE_ID_DELAYED = DEVICE_ID_MAX - 3; +constexpr device_id_t DEVICE_ID_NULL = DEVICE_ID_MAX - 4; +constexpr device_id_t DEVICE_ID_FAKE = DEVICE_ID_MAX - 5; +constexpr device_id_t DEVICE_ID_ZERO = DEVICE_ID_MAX - 6; +constexpr device_id_t DEVICE_ID_MAX_VALID = DEVICE_ID_MAX - 7; + +constexpr device_segment_id_t DEVICE_SEGMENT_ID_MAX = + (1 << SEGMENT_ID_LEN_BITS) - 1; + // Identifies segment location on disk, see SegmentManager, struct segment_id_t { private: @@ -62,47 +77,16 @@ private: 0xF << (std::numeric_limits::digits - DEVICE_ID_LEN_BITS); // default internal segment id static constexpr internal_segment_id_t DEFAULT_INTERNAL_SEG_ID = - std::numeric_limits::max() - 1; + (std::numeric_limits::max() >> 1) - 1; internal_segment_id_t segment = DEFAULT_INTERNAL_SEG_ID; constexpr segment_id_t(uint32_t encoded) : segment(encoded) {} -public: - constexpr static segment_id_t make_max() { - return std::numeric_limits::max(); - } - constexpr static segment_id_t make_null() { - return std::numeric_limits::max() - 1; - } - /* Used to denote relative paddr_t */ - constexpr static segment_id_t make_record_relative() { - return std::numeric_limits::max() - 2; - } - constexpr static segment_id_t make_block_relative() { - return std::numeric_limits::max() - 3; - } - // for tests which generate fake paddrs - constexpr static segment_id_t make_fake() { - return std::numeric_limits::max() - 4; - } - - /* Used to denote references to notional zero filled segment, mainly - * in denoting reserved laddr ranges for unallocated object data. - */ - constexpr static segment_id_t make_zero() { - return std::numeric_limits::max() - 5; - } - constexpr static segment_id_t make_delayed() { - return std::numeric_limits::max() - 6; - } +public: segment_id_t() = default; - segment_id_t(device_id_t id, device_segment_id_t segment) - : segment(make_internal(segment, id)) { - // only lower 4 bits are effective, and we have to reserve 0x0F for - // special XXX_SEG_IDs - assert(id < DEVICE_ID_MAX); - } + constexpr segment_id_t(device_id_t id, device_segment_id_t segment) + : segment(make_internal(segment, id)) {} [[gnu::always_inline]] device_id_t device_id() const { @@ -110,7 +94,7 @@ public: } [[gnu::always_inline]] - device_segment_id_t device_segment_id() const { + constexpr device_segment_id_t device_segment_id() const { return internal_to_segment(segment); } @@ -145,12 +129,12 @@ private: return (static_cast(id) & SM_ID_MASK) >> segment_bits; } - static inline device_segment_id_t internal_to_segment( + constexpr static inline device_segment_id_t internal_to_segment( internal_segment_id_t id) { return id & (~SM_ID_MASK); } - static inline internal_segment_id_t make_internal( + constexpr static inline internal_segment_id_t make_internal( device_segment_id_t id, device_id_t sm_id) { return static_cast(id) | @@ -158,6 +142,9 @@ private: } friend struct segment_id_le_t; + friend struct seg_paddr_t; + friend struct paddr_t; + friend struct paddr_le_t; }; // ondisk type of segment_id_t @@ -172,17 +159,13 @@ struct __attribute((packed)) segment_id_le_t { } }; -constexpr segment_id_t MAX_SEG_ID = segment_id_t::make_max(); -constexpr segment_id_t NULL_SEG_ID = segment_id_t::make_null(); -constexpr segment_id_t RECORD_REL_SEG_ID = segment_id_t::make_record_relative(); -constexpr segment_id_t BLOCK_REL_SEG_ID = segment_id_t::make_block_relative(); +constexpr segment_id_t MAX_SEG_ID = segment_id_t( + DEVICE_ID_MAX, + DEVICE_SEGMENT_ID_MAX +); // for tests which generate fake paddrs -constexpr segment_id_t FAKE_SEG_ID = segment_id_t::make_fake(); -/* Used to denote references to notional zero filled segment, mainly - * in denoting reserved laddr ranges for unallocated object data. - */ -constexpr segment_id_t ZERO_SEG_ID = segment_id_t::make_zero(); -constexpr segment_id_t DELAYED_TEMP_SEG_ID = segment_id_t::make_delayed(); +constexpr segment_id_t NULL_SEG_ID = segment_id_t(DEVICE_ID_NULL, 0); +constexpr segment_id_t FAKE_SEG_ID = segment_id_t(DEVICE_ID_FAKE, 0); std::ostream &operator<<(std::ostream &out, const segment_id_t&); @@ -223,17 +206,17 @@ public: segment_map_t() { // initializes top vector with 0 length vectors to indicate that they // are not yet present - device_to_segments.resize(DEVICE_ID_MAX); + device_to_segments.resize(DEVICE_ID_MAX_VALID); } void add_device(device_id_t device, size_t segments, const T& init) { - assert(device < DEVICE_ID_MAX); + assert(device <= DEVICE_ID_MAX_VALID); assert(device_to_segments[device].size() == 0); device_to_segments[device].resize(segments, init); total_segments += segments; } void clear() { device_to_segments.clear(); - device_to_segments.resize(DEVICE_ID_MAX); + device_to_segments.resize(DEVICE_ID_MAX_VALID); total_segments = 0; } @@ -282,7 +265,7 @@ private: const segment_map_t &, segment_map_t &> parent; - /// points at current device, or DEVICE_ID_MAX if is_end() + /// points at current device, or DEVICE_ID_MAX_VALID if is_end() device_id_t device_id; /// segment at which we are pointing, 0 if is_end() @@ -296,7 +279,7 @@ private: >> current; bool is_end() const { - return device_id == DEVICE_ID_MAX; + return device_id == DEVICE_ID_MAX_VALID; } void find_valid() { @@ -304,7 +287,7 @@ private: auto &device_vec = parent.device_to_segments[device_id]; if (device_vec.size() == 0 || device_segment_id == device_vec.size()) { - while (++device_id < DEVICE_ID_MAX && + while (++device_id < DEVICE_ID_MAX_VALID && parent.device_to_segments[device_id].size() == 0); device_segment_id = 0; } @@ -330,7 +313,7 @@ private: decltype(parent) &parent, device_id_t device_id, device_segment_id_t device_segment_id) { - if (device_id == DEVICE_ID_MAX) { + if (device_id == DEVICE_ID_MAX_VALID) { return end_iterator(parent); } else { auto ret = iterator{parent, device_id, device_segment_id}; @@ -341,7 +324,7 @@ private: static iterator end_iterator( decltype(parent) &parent) { - return iterator{parent, DEVICE_ID_MAX, 0}; + return iterator{parent, DEVICE_ID_MAX_VALID, 0}; } iterator& operator++() { @@ -411,38 +394,79 @@ private: * Fresh extents during a transaction are refered to by * record_relative paddrs. */ +constexpr uint16_t DEV_ADDR_LEN_BITS = 64 - DEVICE_ID_LEN_BITS; +static constexpr uint16_t SEG_OFF_LEN_BITS = 32; +enum class addr_types_t : uint8_t { + SEGMENT = 0, + RANDOM_BLOCK = 1 +}; +struct seg_paddr_t; struct paddr_t { - segment_id_t segment = NULL_SEG_ID; - segment_off_t offset = NULL_SEG_OFF; - - paddr_t() = default; - paddr_t(device_id_t id, device_segment_id_t sgt, segment_off_t offset) - : segment(segment_id_t(id, sgt)), offset(offset) {} - - constexpr paddr_t(segment_id_t segment, segment_off_t offset) - : segment(segment), offset(offset) {} +protected: + using common_addr_t = uint64_t; + common_addr_t dev_addr; +private: + constexpr paddr_t(segment_id_t seg, segment_off_t offset) + : dev_addr((static_cast(seg.segment) + << SEG_OFF_LEN_BITS) | static_cast(offset)) {} + constexpr paddr_t(common_addr_t val) : dev_addr(val) {} +public: + static constexpr paddr_t make_seg_paddr( + segment_id_t seg, segment_off_t offset) { + return paddr_t(seg, offset); + } + static constexpr paddr_t make_seg_paddr( + device_id_t device, + device_segment_id_t seg, + segment_off_t offset) { + return paddr_t(segment_id_t(device, seg), offset); + } + constexpr paddr_t() : paddr_t(NULL_SEG_ID, 0) {} - bool is_relative() const { - return segment == RECORD_REL_SEG_ID || - segment == BLOCK_REL_SEG_ID; + // use 1bit in device_id_t for address type + void set_device_id(device_id_t id, addr_types_t type = addr_types_t::SEGMENT) { + dev_addr &= static_cast( + std::numeric_limits::max()); + dev_addr |= static_cast(id & 0x8) << DEV_ADDR_LEN_BITS; + dev_addr |= static_cast(type) + << (std::numeric_limits::digits - 1); } - bool is_record_relative() const { - return segment == RECORD_REL_SEG_ID; + device_id_t get_device_id() const { + return static_cast(dev_addr >> DEV_ADDR_LEN_BITS); + } + addr_types_t get_addr_type() const { + return (addr_types_t)((dev_addr + >> (std::numeric_limits::digits - 1)) & 1); } + paddr_t add_offset(int32_t o) const; + paddr_t add_relative(paddr_t o) const; + paddr_t add_block_relative(paddr_t o) const; + paddr_t add_record_relative(paddr_t o) const; + paddr_t maybe_relative_to(paddr_t base) const; + + seg_paddr_t& as_seg_paddr(); + const seg_paddr_t& as_seg_paddr() const; + + paddr_t operator-(paddr_t rhs) const; + bool is_block_relative() const { - return segment == BLOCK_REL_SEG_ID; + return get_device_id() == DEVICE_ID_BLOCK_RELATIVE; } - - /// Denotes special zero segment addr - bool is_zero() const { - return segment == ZERO_SEG_ID; + bool is_record_relative() const { + return get_device_id() == DEVICE_ID_RECORD_RELATIVE; } - - /// Denotes special null segment addr + bool is_relative() const { + return is_block_relative() || is_record_relative(); + } + /// Denotes special null addr bool is_null() const { - return segment == NULL_SEG_ID; + return get_device_id() == DEVICE_ID_NULL; + } + /// Denotes special zero addr + bool is_zero() const { + return get_device_id() == DEVICE_ID_ZERO; } /** @@ -456,13 +480,60 @@ struct paddr_t { return !is_zero() && !is_null(); } + DENC(paddr_t, v, p) { + DENC_START(1, 1, p); + denc(v.dev_addr, p); + DENC_FINISH(p); + } + friend struct paddr_le_t; + friend struct seg_paddr_t; + + friend bool operator==(const paddr_t &, const paddr_t&); + friend bool operator!=(const paddr_t &, const paddr_t&); + friend bool operator<=(const paddr_t &, const paddr_t&); + friend bool operator<(const paddr_t &, const paddr_t&); + friend bool operator>=(const paddr_t &, const paddr_t&); + friend bool operator>(const paddr_t &, const paddr_t&); +}; +WRITE_EQ_OPERATORS_1(paddr_t, dev_addr); +WRITE_CMP_OPERATORS_1(paddr_t, dev_addr); + +struct seg_paddr_t : public paddr_t { + static constexpr uint64_t SEG_OFF_MASK = std::numeric_limits::max(); + // mask for segment manager id + static constexpr uint64_t SEG_ID_MASK = + static_cast(0xFFFFFFFF) << SEG_OFF_LEN_BITS; + + seg_paddr_t(const seg_paddr_t&) = delete; + seg_paddr_t(seg_paddr_t&) = delete; + seg_paddr_t& operator=(const seg_paddr_t&) = delete; + seg_paddr_t& operator=(seg_paddr_t&) = delete; + segment_id_t get_segment_id() const { + return segment_id_t((dev_addr & SEG_ID_MASK) >> SEG_OFF_LEN_BITS); + } + segment_off_t get_segment_off() const { + return segment_off_t(dev_addr & SEG_OFF_MASK); + } + void set_segment_id(const segment_id_t id) { + dev_addr &= static_cast( + std::numeric_limits::max()); + dev_addr |= static_cast(id.segment) << SEG_OFF_LEN_BITS; + } + void set_segment_off(const segment_off_t off) { + dev_addr &= static_cast( + std::numeric_limits::max()) << SEG_OFF_LEN_BITS; + dev_addr |= (uint32_t)off; + } + paddr_t add_offset(segment_off_t o) const { - return paddr_t{segment, offset + o}; + return paddr_t::make_seg_paddr(get_segment_id(), get_segment_off() + o); } paddr_t add_relative(paddr_t o) const { assert(o.is_relative()); - return paddr_t{segment, offset + o.offset}; + seg_paddr_t& s = o.as_seg_paddr(); + return paddr_t::make_seg_paddr(get_segment_id(), + get_segment_off() + s.get_segment_off()); } paddr_t add_block_relative(paddr_t o) const { @@ -484,12 +555,13 @@ struct paddr_t { * block_relative address. */ paddr_t operator-(paddr_t rhs) const { + seg_paddr_t& r = rhs.as_seg_paddr(); assert(rhs.is_relative() && is_relative()); - assert(rhs.segment == segment); - return paddr_t{ - BLOCK_REL_SEG_ID, - offset - rhs.offset - }; + assert(r.get_segment_id() == get_segment_id()); + return paddr_t::make_seg_paddr( + segment_id_t{DEVICE_ID_BLOCK_RELATIVE, 0}, + get_segment_off() - r.get_segment_off() + ); } /** @@ -502,54 +574,49 @@ struct paddr_t { */ paddr_t maybe_relative_to(paddr_t base) const { assert(!base.is_block_relative()); + seg_paddr_t& s = base.as_seg_paddr(); if (is_block_relative()) - return base.add_block_relative(*this); + return s.add_block_relative(*this); else return *this; } - - DENC(paddr_t, v, p) { - DENC_START(1, 1, p); - denc(v.segment, p); - denc(v.offset, p); - DENC_FINISH(p); - } }; -WRITE_CMP_OPERATORS_2(paddr_t, segment, offset) -WRITE_EQ_OPERATORS_2(paddr_t, segment, offset) constexpr paddr_t P_ADDR_NULL = paddr_t{}; -constexpr paddr_t P_ADDR_MIN = paddr_t{ZERO_SEG_ID, 0}; -constexpr paddr_t P_ADDR_MAX = paddr_t{ - MAX_SEG_ID, - MAX_SEG_OFF -}; +constexpr paddr_t P_ADDR_MIN = paddr_t::make_seg_paddr(segment_id_t(0, 0), 0); +constexpr paddr_t P_ADDR_MAX = paddr_t::make_seg_paddr( + segment_id_t(DEVICE_ID_MAX, DEVICE_SEGMENT_ID_MAX), + std::numeric_limits::max()); +constexpr paddr_t P_ADDR_ZERO = paddr_t::make_seg_paddr( + DEVICE_ID_ZERO, 0, 0); + constexpr paddr_t make_record_relative_paddr(segment_off_t off) { - return paddr_t{RECORD_REL_SEG_ID, off}; + return paddr_t::make_seg_paddr( + segment_id_t{DEVICE_ID_RECORD_RELATIVE, 0}, + off); } constexpr paddr_t make_block_relative_paddr(segment_off_t off) { - return paddr_t{BLOCK_REL_SEG_ID, off}; + return paddr_t::make_seg_paddr( + segment_id_t{DEVICE_ID_BLOCK_RELATIVE, 0}, + off); } constexpr paddr_t make_fake_paddr(segment_off_t off) { - return paddr_t{FAKE_SEG_ID, off}; -} -constexpr paddr_t zero_paddr() { - return paddr_t{ZERO_SEG_ID, 0}; + return paddr_t::make_seg_paddr(FAKE_SEG_ID, off); } constexpr paddr_t delayed_temp_paddr(segment_off_t off) { - return paddr_t{DELAYED_TEMP_SEG_ID, off}; + return paddr_t::make_seg_paddr( + segment_id_t{DEVICE_ID_DELAYED, 0}, + off); } struct __attribute((packed)) paddr_le_t { - segment_id_le_t segment = segment_id_le_t(NULL_SEG_ID); - ceph_les32 offset = ceph_les32(NULL_SEG_OFF); + ceph_le64 dev_addr = + ceph_le64(P_ADDR_NULL.dev_addr); paddr_le_t() = default; - paddr_le_t(segment_id_t segment, segment_off_t offset) - : segment(segment), offset(ceph_les32(offset)) {} - paddr_le_t(const paddr_t &addr) : paddr_le_t(addr.segment, addr.offset) {} + paddr_le_t(const paddr_t &addr) : dev_addr(ceph_le64(addr.dev_addr)) {} operator paddr_t() const { - return paddr_t{segment, offset}; + return paddr_t{dev_addr}; } }; @@ -600,7 +667,7 @@ WRITE_CMP_OPERATORS_2(journal_seq_t, segment_seq, offset) WRITE_EQ_OPERATORS_2(journal_seq_t, segment_seq, offset) constexpr journal_seq_t JOURNAL_SEQ_MIN{ 0, - paddr_t{ZERO_SEG_ID, 0} + paddr_t::make_seg_paddr(NULL_SEG_ID, 0) }; constexpr journal_seq_t JOURNAL_SEQ_MAX{ MAX_SEG_SEQ, @@ -1219,15 +1286,17 @@ struct scan_valid_records_cursor { } segment_id_t get_segment_id() const { - return seq.offset.segment; + return seq.offset.as_seg_paddr().get_segment_id(); } segment_off_t get_segment_offset() const { - return seq.offset.offset; + return seq.offset.as_seg_paddr().get_segment_off(); } void increment(segment_off_t off) { - seq.offset.offset += off; + auto& seg_addr = seq.offset.as_seg_paddr(); + seg_addr.set_segment_off( + seg_addr.get_segment_off() + off); } scan_valid_records_cursor( @@ -1235,6 +1304,60 @@ struct scan_valid_records_cursor { : seq(seq) {} }; +inline const seg_paddr_t& paddr_t::as_seg_paddr() const { + assert(get_addr_type() == addr_types_t::SEGMENT); + return *static_cast(this); +} + +inline seg_paddr_t& paddr_t::as_seg_paddr() { + assert(get_addr_type() == addr_types_t::SEGMENT); + return *static_cast(this); +} + +inline paddr_t paddr_t::operator-(paddr_t rhs) const { + if (get_addr_type() == addr_types_t::SEGMENT) { + auto& seg_addr = as_seg_paddr(); + return seg_addr - rhs; + } + ceph_assert(0 == "not supported type"); + return paddr_t{}; +} + +#define PADDR_OPERATION(a_type, base, func) \ + if (get_addr_type() == a_type) { \ + return static_cast(this)->func; \ + } + +inline paddr_t paddr_t::add_offset(int32_t o) const { + PADDR_OPERATION(addr_types_t::SEGMENT, seg_paddr_t, add_offset(o)) + ceph_assert(0 == "not supported type"); + return paddr_t{}; +} + +inline paddr_t paddr_t::add_relative(paddr_t o) const { + PADDR_OPERATION(addr_types_t::SEGMENT, seg_paddr_t, add_relative(o)) + ceph_assert(0 == "not supported type"); + return paddr_t{}; +} + +inline paddr_t paddr_t::add_block_relative(paddr_t o) const { + PADDR_OPERATION(addr_types_t::SEGMENT, seg_paddr_t, add_block_relative(o)) + ceph_assert(0 == "not supported type"); + return paddr_t{}; +} + +inline paddr_t paddr_t::add_record_relative(paddr_t o) const { + PADDR_OPERATION(addr_types_t::SEGMENT, seg_paddr_t, add_record_relative(o)) + ceph_assert(0 == "not supported type"); + return paddr_t{}; +} + +inline paddr_t paddr_t::maybe_relative_to(paddr_t o) const { + PADDR_OPERATION(addr_types_t::SEGMENT, seg_paddr_t, maybe_relative_to(o)) + ceph_assert(0 == "not supported type"); + return paddr_t{}; +} + } WRITE_CLASS_DENC_BOUNDED(crimson::os::seastore::seastore_meta_t) diff --git a/src/crimson/os/seastore/segment_cleaner.cc b/src/crimson/os/seastore/segment_cleaner.cc index e209cf47fbf..dc7664cb3a7 100644 --- a/src/crimson/os/seastore/segment_cleaner.cc +++ b/src/crimson/os/seastore/segment_cleaner.cc @@ -200,7 +200,7 @@ SegmentCleaner::get_segment_ret SegmentCleaner::get_segment(device_id_t id) assert(0 == "out of space handling todo"); return get_segment_ret( get_segment_ertr::ready_future_marker{}, - ZERO_SEG_ID); + NULL_SEG_ID); } void SegmentCleaner::update_journal_tail_target(journal_seq_t target) diff --git a/src/crimson/os/seastore/segment_cleaner.h b/src/crimson/os/seastore/segment_cleaner.h index 04fa9f6bab5..ef7fb731d7e 100644 --- a/src/crimson/os/seastore/segment_cleaner.h +++ b/src/crimson/os/seastore/segment_cleaner.h @@ -168,7 +168,7 @@ public: sm_info->avail_bytes += sm_info->segment_size; } void space_used(paddr_t addr, extent_len_t len) { - auto& sm_info = sm_infos[addr.segment.device_id()]; + auto& sm_info = sm_infos[addr.get_device_id()]; sm_info->avail_bytes -= len; } size_t get_empty_segments(device_id_t d_id) { @@ -730,18 +730,19 @@ public: paddr_t addr, extent_len_t len, bool init_scan = false) { - assert(addr.segment.device_id() == - segments[addr.segment.device_id()]->device_id); - assert(addr.segment.device_segment_id() < - segments[addr.segment.device_id()]->num_segments); + auto& seg_addr = addr.as_seg_paddr(); + assert(seg_addr.get_segment_id().device_id() == + segments[seg_addr.get_segment_id().device_id()]->device_id); + assert(seg_addr.get_segment_id().device_segment_id() < + segments[seg_addr.get_segment_id().device_id()]->num_segments); if (!init_scan && !init_complete) return; used_bytes += len; [[maybe_unused]] auto ret = space_tracker->allocate( - addr.segment, - addr.offset, + seg_addr.get_segment_id(), + seg_addr.get_segment_off(), len); segments.space_used(addr, len); gc_process.maybe_wake_on_space_used(); @@ -756,14 +757,15 @@ public: ceph_assert(used_bytes >= len); used_bytes -= len; - assert(addr.segment.device_id() == - segments[addr.segment.device_id()]->device_id); - assert(addr.segment.device_segment_id() < - segments[addr.segment.device_id()]->num_segments); + auto& seg_addr = addr.as_seg_paddr(); + assert(addr.get_device_id() == + segments[seg_addr.get_segment_id().device_id()]->device_id); + assert(seg_addr.get_segment_id().device_segment_id() < + segments[seg_addr.get_segment_id().device_id()]->num_segments); [[maybe_unused]] auto ret = space_tracker->release( - addr.segment, - addr.offset, + seg_addr.get_segment_id(), + seg_addr.get_segment_off(), len); maybe_wake_gc_blocked_io(); assert(ret >= 0); @@ -791,7 +793,7 @@ public: "SegmentCleaner::get_next_gc_target: segment {} seq {}", id, seq); - return journal_seq_t{seq, {id, 0}}; + return journal_seq_t{seq, paddr_t::make_seg_paddr(id, 0)}; } else { return journal_seq_t(); } @@ -966,12 +968,14 @@ private: gc_reclaim_space_ret gc_reclaim_space(); size_t get_bytes_used_current_segment() const { - return journal_head.offset.offset; + auto& seg_addr = journal_head.offset.as_seg_paddr(); + return seg_addr.get_segment_off(); } size_t get_bytes_available_current_segment() const { + auto& seg_addr = journal_head.offset.as_seg_paddr(); auto segment_size = - segments[journal_head.offset.segment.device_id()]->segment_size; + segments[seg_addr.get_segment_id().device_id()]->segment_size; return segment_size - get_bytes_used_current_segment(); } @@ -984,7 +988,6 @@ private: size_t get_bytes_scanned_current_segment() const { if (!scan_cursor) return 0; - return scan_cursor->get_segment_offset(); } @@ -1029,8 +1032,9 @@ private: return segments.get_journal_segments() * segments[journal_device_id]->segment_size; } else { assert(journal_head >= journal_tail_committed); + auto& seg_addr = journal_head.offset.as_seg_paddr(); auto segment_size = - segments[journal_head.offset.segment.device_id()]->segment_size; + segments[seg_addr.get_segment_id().device_id()]->segment_size; return (journal_head.segment_seq - journal_tail_committed.segment_seq + 1) * segment_size; } @@ -1208,6 +1212,7 @@ private: return gc_should_reclaim_space() || gc_should_trim_journal(); } + void mark_closed(segment_id_t segment) { assert(segment.device_id() == segments[segment.device_id()]->device_id); diff --git a/src/crimson/os/seastore/segment_manager/block.cc b/src/crimson/os/seastore/segment_manager/block.cc index f623cee7cbf..61b67790054 100644 --- a/src/crimson/os/seastore/segment_manager/block.cc +++ b/src/crimson/os/seastore/segment_manager/block.cc @@ -366,7 +366,7 @@ Segment::write_ertr::future<> BlockSegment::write( return crimson::ct_error::enospc::make(); write_pointer = offset + bl.length(); - return manager.segment_write({id, offset}, bl); + return manager.segment_write(paddr_t::make_seg_paddr(id, offset), bl); } Segment::close_ertr::future<> BlockSegmentManager::segment_close( @@ -389,13 +389,14 @@ Segment::write_ertr::future<> BlockSegmentManager::segment_write( ceph::bufferlist bl, bool ignore_check) { - assert(addr.segment.device_id() == get_device_id()); + assert(addr.get_device_id() == get_device_id()); assert((bl.length() % superblock.block_size) == 0); + auto& seg_addr = addr.as_seg_paddr(); logger().debug( "BlockSegmentManager::segment_write: " "segment_write to segment {} at offset {}, physical offset {}, len {}", - addr.segment, - addr.offset, + seg_addr.get_segment_id(), + seg_addr.get_segment_off(), get_offset(addr), bl.length()); stats.data_write.increment(bl.length()); @@ -551,15 +552,16 @@ SegmentManager::read_ertr::future<> BlockSegmentManager::read( size_t len, ceph::bufferptr &out) { - assert(addr.segment.device_id() == get_device_id()); - if (addr.segment.device_segment_id() >= get_num_segments()) { + assert(addr.get_device_id() == get_device_id()); + auto& seg_addr = addr.as_seg_paddr(); + if (seg_addr.get_segment_id().device_segment_id() >= get_num_segments()) { logger().error( "BlockSegmentManager::read: invalid segment {}", addr); return crimson::ct_error::invarg::make(); } - if (addr.offset + len > superblock.segment_size) { + if (seg_addr.get_segment_off() + len > superblock.segment_size) { logger().error( "BlockSegmentManager::read: invalid offset {}~{}!", addr, @@ -567,11 +569,12 @@ SegmentManager::read_ertr::future<> BlockSegmentManager::read( return crimson::ct_error::invarg::make(); } - if (tracker->get(addr.segment.device_segment_id()) == segment_state_t::EMPTY) { + if (tracker->get(seg_addr.get_segment_id().device_segment_id()) == + segment_state_t::EMPTY) { logger().error( "BlockSegmentManager::read: read on invalid segment {} state {}", - addr.segment, - tracker->get(addr.segment.device_segment_id())); + seg_addr.get_segment_id(), + tracker->get(seg_addr.get_segment_id().device_segment_id())); return crimson::ct_error::enoent::make(); } diff --git a/src/crimson/os/seastore/segment_manager/block.h b/src/crimson/os/seastore/segment_manager/block.h index 5ce2943f461..27d39a287eb 100644 --- a/src/crimson/os/seastore/segment_manager/block.h +++ b/src/crimson/os/seastore/segment_manager/block.h @@ -206,9 +206,10 @@ private: device_id_t device_id = 0; size_t get_offset(paddr_t addr) { + auto& seg_addr = addr.as_seg_paddr(); return superblock.first_segment_offset + - (addr.segment.device_segment_id() * superblock.segment_size) + - addr.offset; + (seg_addr.get_segment_id().device_segment_id() * superblock.segment_size) + + seg_addr.get_segment_off(); } const seastore_meta_t &get_meta() const { diff --git a/src/crimson/os/seastore/segment_manager/ephemeral.cc b/src/crimson/os/seastore/segment_manager/ephemeral.cc index 32e3166fe09..ea24699a762 100644 --- a/src/crimson/os/seastore/segment_manager/ephemeral.cc +++ b/src/crimson/os/seastore/segment_manager/ephemeral.cc @@ -54,7 +54,7 @@ Segment::write_ertr::future<> EphemeralSegment::write( if (offset + bl.length() > (size_t)manager.get_segment_size()) return crimson::ct_error::enospc::make(); - return manager.segment_write({id, offset}, bl); + return manager.segment_write(paddr_t::make_seg_paddr(id, offset), bl); } Segment::close_ertr::future<> EphemeralSegmentManager::segment_close(segment_id_t id) @@ -74,14 +74,16 @@ Segment::write_ertr::future<> EphemeralSegmentManager::segment_write( ceph::bufferlist bl, bool ignore_check) { + auto& seg_addr = addr.as_seg_paddr(); logger().debug( "segment_write to segment {} at offset {}, physical offset {}, len {}, crc {}", - addr.segment, - addr.offset, + seg_addr.get_segment_id(), + seg_addr.get_segment_off(), get_offset(addr), bl.length(), bl.crc32c(1)); - if (!ignore_check && segment_state[addr.segment.device_segment_id()] != segment_state_t::OPEN) + if (!ignore_check && segment_state[seg_addr.get_segment_id().device_segment_id()] + != segment_state_t::OPEN) return crimson::ct_error::invarg::make(); bl.begin().copy(bl.length(), buffer + get_offset(addr)); @@ -181,7 +183,7 @@ SegmentManager::release_ertr::future<> EphemeralSegmentManager::release( return crimson::ct_error::invarg::make(); } - ::memset(buffer + get_offset({id, 0}), 0, config.segment_size); + ::memset(buffer + get_offset(paddr_t::make_seg_paddr(id, 0)), 0, config.segment_size); segment_state[s_id] = segment_state_t::EMPTY; return release_ertr::now().safe_then([] { return seastar::sleep(std::chrono::milliseconds(1)); @@ -193,14 +195,15 @@ SegmentManager::read_ertr::future<> EphemeralSegmentManager::read( size_t len, ceph::bufferptr &out) { - if (addr.segment.device_segment_id() >= get_num_segments()) { + auto& seg_addr = addr.as_seg_paddr(); + if (seg_addr.get_segment_id().device_segment_id() >= get_num_segments()) { logger().error( "EphemeralSegmentManager::read: invalid segment {}", addr); return crimson::ct_error::invarg::make(); } - if (addr.offset + len > config.segment_size) { + if (seg_addr.get_segment_off() + len > config.segment_size) { logger().error( "EphemeralSegmentManager::read: invalid offset {}~{}!", addr, @@ -214,8 +217,8 @@ SegmentManager::read_ertr::future<> EphemeralSegmentManager::read( bl.push_back(out); logger().debug( "segment_read to segment {} at offset {}, physical offset {}, length {}, crc {}", - addr.segment.device_segment_id(), - addr.offset, + seg_addr.get_segment_id().device_segment_id(), + seg_addr.get_segment_off(), get_offset(addr), len, bl.begin().crc32c(len, 1)); diff --git a/src/crimson/os/seastore/segment_manager/ephemeral.h b/src/crimson/os/seastore/segment_manager/ephemeral.h index 10fd2c6b345..7083c08c89b 100644 --- a/src/crimson/os/seastore/segment_manager/ephemeral.h +++ b/src/crimson/os/seastore/segment_manager/ephemeral.h @@ -62,7 +62,9 @@ class EphemeralSegmentManager final : public SegmentManager { std::optional meta; size_t get_offset(paddr_t addr) { - return (addr.segment.device_segment_id() * config.segment_size) + addr.offset; + auto& seg_addr = addr.as_seg_paddr(); + return (seg_addr.get_segment_id().device_segment_id() * config.segment_size) + + seg_addr.get_segment_off(); } std::vector segment_state; diff --git a/src/crimson/os/seastore/transaction_manager.h b/src/crimson/os/seastore/transaction_manager.h index 7dc7b654c41..50c5c1c1206 100644 --- a/src/crimson/os/seastore/transaction_manager.h +++ b/src/crimson/os/seastore/transaction_manager.h @@ -322,7 +322,7 @@ public: t, hint, len, - zero_paddr()); + P_ADDR_ZERO); } /* alloc_extents diff --git a/src/test/crimson/seastore/test_randomblock_manager.cc b/src/test/crimson/seastore/test_randomblock_manager.cc index 1277c245ed9..02f266454da 100644 --- a/src/test/crimson/seastore/test_randomblock_manager.cc +++ b/src/test/crimson/seastore/test_randomblock_manager.cc @@ -55,8 +55,8 @@ struct rbm_test_t : seastar::future<> set_up_fut() final { device.reset(new nvme_device::TestMemory(DEFAULT_TEST_SIZE)); rbm_manager.reset(new NVMeManager(device.get(), std::string())); - config.start = paddr_t {0, 0, 0}; - config.end = paddr_t {0, 0, DEFAULT_TEST_SIZE}; + config.start = paddr_t::make_seg_paddr(0, 0, 0); + config.end = paddr_t::make_seg_paddr(0, 0, DEFAULT_TEST_SIZE); config.block_size = DEFAULT_BLOCK_SIZE; config.total_size = DEFAULT_TEST_SIZE; return tm_setup(); @@ -287,8 +287,8 @@ TEST_F(rbm_test_t, block_alloc_free_test) TEST_F(rbm_test_t, many_block_alloc) { run_async([this] { - config.start = paddr_t {0, 0, 0}; - config.end = paddr_t {0, 0, DEFAULT_TEST_SIZE * 1024}; + config.start = paddr_t::make_seg_paddr(0, 0, 0); + config.end = paddr_t::make_seg_paddr(0, 0, DEFAULT_TEST_SIZE * 1024); config.block_size = DEFAULT_BLOCK_SIZE; config.total_size = DEFAULT_TEST_SIZE * 1024; mkfs(); diff --git a/src/test/crimson/seastore/test_seastore_cache.cc b/src/test/crimson/seastore/test_seastore_cache.cc index 29336e6ca0d..a55bb4287b5 100644 --- a/src/test/crimson/seastore/test_seastore_cache.cc +++ b/src/test/crimson/seastore/test_seastore_cache.cc @@ -39,16 +39,18 @@ struct cache_test_t : public seastar_test_suite_t { ceph_assert((segment_off_t)bl.length() < segment_manager->get_segment_size()); - if (current.offset + (segment_off_t)bl.length() > + if (current.as_seg_paddr().get_segment_off() + (segment_off_t)bl.length() > segment_manager->get_segment_size()) - current = paddr_t{ + current = paddr_t::make_seg_paddr( segment_id_t( - current.segment.device_id(), - current.segment.device_segment_id() + 1), - 0}; + current.as_seg_paddr().get_segment_id().device_id(), + current.as_seg_paddr().get_segment_id().device_segment_id() + 1), + 0); auto prev = current; - current.offset += bl.length(); + current.as_seg_paddr().set_segment_off( + current.as_seg_paddr().get_segment_off() + + bl.length()); return segment_manager->segment_write( prev, std::move(bl), @@ -82,7 +84,7 @@ struct cache_test_t : public seastar_test_suite_t { segment_manager = segment_manager::create_test_ephemeral(); reader.reset(new ExtentReader()); cache.reset(new Cache(*reader)); - current = paddr_t(segment_id_t(segment_manager->get_device_id(), 0), 0); + current = paddr_t::make_seg_paddr(segment_id_t(segment_manager->get_device_id(), 0), 0); reader->add_segment_manager(segment_manager.get()); return segment_manager->init( ).safe_then([this] { diff --git a/src/test/crimson/seastore/test_seastore_journal.cc b/src/test/crimson/seastore/test_seastore_journal.cc index 366f3f3b9b8..0186a59c405 100644 --- a/src/test/crimson/seastore/test_seastore_journal.cc +++ b/src/test/crimson/seastore/test_seastore_journal.cc @@ -33,7 +33,9 @@ struct record_validator_t { auto test = manager.read( record_final_offset.add_relative(addr), block.bl.length()).unsafe_get0(); - addr.offset += block.bl.length(); + addr.as_seg_paddr().set_segment_off( + addr.as_seg_paddr().get_segment_off() + + block.bl.length()); bufferlist bl; bl.push_back(test); ASSERT_EQ( @@ -306,9 +308,9 @@ TEST_F(journal_test_t, roll_journal_and_replay) { generate_extent(1), generate_extent(2) }, { generate_delta(23), generate_delta(30) } }); - auto starting_segment = current.segment; + auto starting_segment = current.as_seg_paddr().get_segment_id(); unsigned so_far = 0; - while (current.segment == starting_segment) { + while (current.as_seg_paddr().get_segment_id() == starting_segment) { current = submit_record(record_t{ { generate_extent(512), generate_extent(512) }, { generate_delta(23), generate_delta(400) } diff --git a/src/test/crimson/seastore/test_transaction_manager.cc b/src/test/crimson/seastore/test_transaction_manager.cc index b1c85584cb6..8a7d0f03141 100644 --- a/src/test/crimson/seastore/test_transaction_manager.cc +++ b/src/test/crimson/seastore/test_transaction_manager.cc @@ -392,8 +392,8 @@ struct transaction_manager_test_t : t, [&tracker](auto offset, auto len) { tracker->allocate( - offset.segment, - offset.offset, + offset.as_seg_paddr().get_segment_id(), + offset.as_seg_paddr().get_segment_off(), len); }); }).unsafe_get0(); -- 2.39.5