From: Yingxin Cheng Date: Fri, 30 Sep 2022 03:11:01 +0000 (+0800) Subject: crimson/os/seastore: use device_off_t for offset at seastore level X-Git-Tag: v18.1.0~1035^2~1 X-Git-Url: http://git-server-git.apps.pok.os.sepia.ceph.com/?a=commitdiff_plain;h=ac5b9e8a692c20da73c296f368de9766ef2f370d;p=ceph.git crimson/os/seastore: use device_off_t for offset at seastore level * Replace the reset of seastore_off_t by the extended device_off_t. * Extend offset from 32-bit to 56-bit signed integer at seastore level. * res_paddr_t to embed device_off_t. * blk_paddr_t to use signed device_off_t for consistency. Signed-off-by: Yingxin Cheng --- diff --git a/src/crimson/os/seastore/async_cleaner.cc b/src/crimson/os/seastore/async_cleaner.cc index 481b98b9ad64..322f54ee3d9c 100644 --- a/src/crimson/os/seastore/async_cleaner.cc +++ b/src/crimson/os/seastore/async_cleaner.cc @@ -404,8 +404,8 @@ JournalTrimmerImpl::JournalTrimmerImpl( BackrefManager &backref_manager, config_t config, journal_type_t type, - seastore_off_t roll_start, - seastore_off_t roll_size) + device_off_t roll_start, + device_off_t roll_size) : backref_manager(backref_manager), config(config), journal_type(type), diff --git a/src/crimson/os/seastore/async_cleaner.h b/src/crimson/os/seastore/async_cleaner.h index 343d78bd7a56..ded2a3da8ac1 100644 --- a/src/crimson/os/seastore/async_cleaner.h +++ b/src/crimson/os/seastore/async_cleaner.h @@ -483,8 +483,8 @@ public: BackrefManager &backref_manager, config_t config, journal_type_t type, - seastore_off_t roll_start, - seastore_off_t roll_size); + device_off_t roll_start, + device_off_t roll_size); ~JournalTrimmerImpl() = default; @@ -549,8 +549,8 @@ public: BackrefManager &backref_manager, config_t config, journal_type_t type, - seastore_off_t roll_start, - seastore_off_t roll_size) { + device_off_t roll_start, + device_off_t roll_size) { return std::make_unique( backref_manager, config, type, roll_start, roll_size); } @@ -575,8 +575,8 @@ private: config_t config; journal_type_t journal_type; - seastore_off_t roll_start; - seastore_off_t roll_size; + device_off_t roll_start; + device_off_t roll_size; journal_seq_t journal_head; journal_seq_t journal_dirty_tail; diff --git a/src/crimson/os/seastore/backref/btree_backref_manager.cc b/src/crimson/os/seastore/backref/btree_backref_manager.cc index ae2da76527ea..5c47001e7797 100644 --- a/src/crimson/os/seastore/backref/btree_backref_manager.cc +++ b/src/crimson/os/seastore/backref/btree_backref_manager.cc @@ -125,7 +125,7 @@ BtreeBackrefManager::new_mapping( is_aligned( key.get_addr_type() == paddr_types_t::SEGMENT ? key.as_seg_paddr().get_segment_off() : - key.as_blk_paddr().get_block_off(), + key.as_blk_paddr().get_device_off(), cache.get_block_size())); struct state_t { paddr_t last_end; diff --git a/src/crimson/os/seastore/random_block_manager.h b/src/crimson/os/seastore/random_block_manager.h index e6fc09834f59..722685e80a47 100644 --- a/src/crimson/os/seastore/random_block_manager.h +++ b/src/crimson/os/seastore/random_block_manager.h @@ -103,7 +103,7 @@ using rbm_abs_addr = uint64_t; inline rbm_abs_addr convert_paddr_to_abs_addr(const paddr_t& paddr) { const blk_paddr_t& blk_addr = paddr.as_blk_paddr(); - return blk_addr.get_block_off(); + return blk_addr.get_device_off(); } inline paddr_t convert_abs_addr_to_paddr(rbm_abs_addr addr, device_id_t d_id) { diff --git a/src/crimson/os/seastore/seastore_types.cc b/src/crimson/os/seastore/seastore_types.cc index 32f447bcf18e..becc16ce6d28 100644 --- a/src/crimson/os/seastore/seastore_types.cc +++ b/src/crimson/os/seastore/seastore_types.cc @@ -108,11 +108,11 @@ std::ostream &operator<<(std::ostream &out, const paddr_t &rhs) out << "MIN"; } else if (rhs == P_ADDR_ZERO) { out << "ZERO"; - } else if (has_seastore_off(id)) { + } else if (has_device_off(id)) { auto &s = rhs.as_res_paddr(); out << device_id_printer_t{id} << "," - << seastore_off_printer_t{s.get_seastore_off()}; + << s.get_device_off(); } else if (rhs.get_addr_type() == paddr_types_t::SEGMENT) { auto &s = rhs.as_seg_paddr(); out << s.get_segment_id() @@ -122,7 +122,7 @@ std::ostream &operator<<(std::ostream &out, const paddr_t &rhs) auto &s = rhs.as_blk_paddr(); out << device_id_printer_t{s.get_device_id()} << "," - << s.get_block_off(); + << s.get_device_off(); } else { out << "INVALID!"; } @@ -132,8 +132,8 @@ std::ostream &operator<<(std::ostream &out, const paddr_t &rhs) journal_seq_t journal_seq_t::add_offset( journal_type_t type, device_off_t off, - seastore_off_t roll_start, - seastore_off_t roll_size) const + device_off_t roll_start, + device_off_t roll_size) const { assert(offset.is_absolute()); assert(off <= DEVICE_OFF_MAX && off >= DEVICE_OFF_MIN); @@ -141,12 +141,12 @@ journal_seq_t journal_seq_t::add_offset( assert(roll_size > 0); segment_seq_t jseq = segment_seq; - seastore_off_t joff; + device_off_t joff; if (type == journal_type_t::SEGMENTED) { joff = offset.as_seg_paddr().get_segment_off(); } else { assert(type == journal_type_t::RANDOM_BLOCK); - auto boff = offset.as_blk_paddr().get_block_off(); + auto boff = offset.as_blk_paddr().get_device_off(); assert(boff <= MAX_SEG_OFF); joff = boff; } @@ -184,8 +184,8 @@ journal_seq_t journal_seq_t::add_offset( device_off_t journal_seq_t::relative_to( journal_type_t type, const journal_seq_t& r, - seastore_off_t roll_start, - seastore_off_t roll_size) const + device_off_t roll_start, + device_off_t roll_size) const { assert(offset.is_absolute()); assert(r.offset.is_absolute()); @@ -199,8 +199,8 @@ device_off_t journal_seq_t::relative_to( static_cast(r.offset.as_seg_paddr().get_segment_off())); } else { assert(type == journal_type_t::RANDOM_BLOCK); - ret += (static_cast(offset.as_blk_paddr().get_block_off()) - - static_cast(r.offset.as_blk_paddr().get_block_off())); + ret += offset.as_blk_paddr().get_device_off() - + r.offset.as_blk_paddr().get_device_off(); } assert(ret <= DEVICE_OFF_MAX && ret >= DEVICE_OFF_MIN); return ret; diff --git a/src/crimson/os/seastore/seastore_types.h b/src/crimson/os/seastore/seastore_types.h index 14640da65502..5f2f3341e2a3 100644 --- a/src/crimson/os/seastore/seastore_types.h +++ b/src/crimson/os/seastore/seastore_types.h @@ -92,7 +92,7 @@ constexpr paddr_types_t device_id_to_paddr_type(device_id_t id) { } } -constexpr bool has_seastore_off(device_id_t id) { +constexpr bool has_device_off(device_id_t id) { return id == DEVICE_ID_RECORD_RELATIVE || id == DEVICE_ID_BLOCK_RELATIVE || id == DEVICE_ID_DELAYED || @@ -462,6 +462,7 @@ static_assert(PADDR_BITS == SEGMENT_ID_BITS + SEGMENT_OFF_BITS); * TODO: replace block_off_t */ using device_off_t = int64_t; +using u_device_off_t = uint64_t; constexpr auto DEVICE_OFF_BITS = PADDR_BITS - DEVICE_ID_BITS; constexpr auto DEVICE_OFF_MAX = std::numeric_limits::max() >> DEVICE_ID_BITS; @@ -483,22 +484,34 @@ using segment_off_t = int32_t; using u_segment_off_t = uint32_t; constexpr auto DEVICE_ID_MASK = - ((internal_paddr_t(1) << DEVICE_ID_BITS) - 1) << BLOCK_OFF_BITS; -constexpr auto BLOCK_OFF_MASK = - static_cast(BLOCK_OFF_MAX); + ((internal_paddr_t(1) << DEVICE_ID_BITS) - 1) << DEVICE_OFF_BITS; +constexpr auto DEVICE_OFF_MASK = + std::numeric_limits::max() >> DEVICE_ID_BITS; constexpr auto SEGMENT_ID_MASK = ((internal_paddr_t(1) << SEGMENT_ID_BITS) - 1) << SEGMENT_OFF_BITS; constexpr auto SEGMENT_OFF_MASK = (internal_paddr_t(1) << SEGMENT_OFF_BITS) - 1; constexpr auto SEASTORE_OFF_MASK = SEGMENT_OFF_MASK; +constexpr internal_paddr_t encode_device_off(device_off_t off) { + return static_cast(off) & DEVICE_OFF_MASK; +} + +constexpr device_off_t decode_device_off(internal_paddr_t addr) { + if (addr & (1ull << (DEVICE_OFF_BITS - 1))) { + return static_cast(addr | DEVICE_ID_MASK); + } else { + return static_cast(addr & DEVICE_OFF_MASK); + } +} + struct seg_paddr_t; struct blk_paddr_t; struct res_paddr_t; struct paddr_t { public: // P_ADDR_MAX == P_ADDR_NULL == paddr_t{} - paddr_t() : paddr_t(DEVICE_ID_MAX, seastore_off_t(0)) {} + paddr_t() : paddr_t(DEVICE_ID_MAX, device_off_t(0)) {} static paddr_t make_seg_paddr( segment_id_t seg, @@ -515,13 +528,15 @@ public: static paddr_t make_blk_paddr( device_id_t device, - block_off_t offset) { + device_off_t offset) { + assert(device_id_to_paddr_type(device) == paddr_types_t::RANDOM_BLOCK); return paddr_t(device, offset); } static paddr_t make_res_paddr( device_id_t device, - seastore_off_t offset) { + device_off_t offset) { + assert(device_id_to_paddr_type(device) == paddr_types_t::RESERVED); return paddr_t(device, offset); } @@ -530,14 +545,14 @@ public: } device_id_t get_device_id() const { - return static_cast(internal_paddr >> BLOCK_OFF_BITS); + return static_cast(internal_paddr >> DEVICE_OFF_BITS); } paddr_types_t get_addr_type() const { return device_id_to_paddr_type(get_device_id()); } - paddr_t add_offset(seastore_off_t o) const; + paddr_t add_offset(device_off_t o) const; paddr_t add_relative(paddr_t o) const; @@ -579,7 +594,7 @@ public: paddr_t block_relative_to(paddr_t rhs) const; // To be compatible with laddr_t operator+ - paddr_t operator+(seastore_off_t o) const { + paddr_t operator+(device_off_t o) const { return add_offset(o); } @@ -627,7 +642,7 @@ public: } bool is_absolute() const { - return device_id_to_paddr_type(get_device_id()) != paddr_types_t::RESERVED; + return get_addr_type() != paddr_types_t::RESERVED; } auto operator<=>(const paddr_t &) const = default; @@ -639,8 +654,8 @@ public: } constexpr static paddr_t create_const( - device_id_t d_id, device_segment_id_t s_id, seastore_off_t offset) { - return paddr_t(d_id, s_id, offset); + device_id_t d_id, device_off_t offset) { + return paddr_t(d_id, offset, const_construct_t()); } protected: @@ -652,27 +667,21 @@ private: : paddr_t((static_cast(seg.segment) << SEGMENT_OFF_BITS) | static_cast(offset)) {} - // as blk - paddr_t(device_id_t d_id, block_off_t offset) - : paddr_t((static_cast(d_id) << BLOCK_OFF_BITS) | - (offset & BLOCK_OFF_MASK)) { - assert(device_id_to_paddr_type(get_device_id()) == paddr_types_t::RANDOM_BLOCK); - assert(offset <= BLOCK_OFF_MAX); - } - - // as res - paddr_t(device_id_t d_id, seastore_off_t offset) - : paddr_t((static_cast(d_id) << BLOCK_OFF_BITS) | - static_cast(offset)) { - assert(device_id_to_paddr_type(get_device_id()) == paddr_types_t::RESERVED); + // as blk or res + paddr_t(device_id_t d_id, device_off_t offset) + : paddr_t((static_cast(d_id) << DEVICE_OFF_BITS) | + encode_device_off(offset)) { + assert(offset >= DEVICE_OFF_MIN); + assert(offset <= DEVICE_OFF_MAX); + assert(get_addr_type() != paddr_types_t::SEGMENT); } paddr_t(internal_paddr_t val); - constexpr paddr_t(device_id_t d_id, device_segment_id_t s_id, seastore_off_t offset) + struct const_construct_t {}; + constexpr paddr_t(device_id_t d_id, device_off_t offset, const_construct_t) : internal_paddr((static_cast(d_id) << BLOCK_OFF_BITS) | - (static_cast(s_id) << SEGMENT_OFF_BITS) | - static_cast(offset)) {} + static_cast(offset)) {} friend struct paddr_le_t; }; @@ -700,7 +709,7 @@ struct seg_paddr_t : public paddr_t { internal_paddr |= static_cast(off); } - paddr_t add_offset(seastore_off_t o) const { + paddr_t add_offset(device_off_t o) const { device_off_t off = get_segment_off() + o; assert(off >= 0); assert(off <= MAX_SEG_OFF); @@ -715,19 +724,21 @@ struct blk_paddr_t : public paddr_t { blk_paddr_t& operator=(const blk_paddr_t&) = delete; blk_paddr_t& operator=(blk_paddr_t&) = delete; - block_off_t get_block_off() const { - return block_off_t(internal_paddr & BLOCK_OFF_MASK); + device_off_t get_device_off() const { + return decode_device_off(internal_paddr); } - void set_block_off(block_off_t off) { - assert(off <= BLOCK_OFF_MAX); + void set_device_off(device_off_t off) { + assert(off >= 0); + assert(off <= DEVICE_OFF_MAX); internal_paddr = (internal_paddr & DEVICE_ID_MASK); - internal_paddr |= (off & BLOCK_OFF_MASK); + internal_paddr |= encode_device_off(off); } - paddr_t add_offset(seastore_off_t o) const { - auto off = get_block_off() + o; - assert(o >= 0 ? off >= get_block_off() : off < get_block_off()); + paddr_t add_offset(device_off_t o) const { + assert(o >= DEVICE_OFF_MIN); + assert(o <= DEVICE_OFF_MAX); + auto off = get_device_off() + o; return paddr_t::make_blk_paddr(get_device_id(), off); } }; @@ -738,49 +749,50 @@ struct res_paddr_t : public paddr_t { res_paddr_t& operator=(const res_paddr_t&) = delete; res_paddr_t& operator=(res_paddr_t&) = delete; - seastore_off_t get_seastore_off() const { - return seastore_off_t(internal_paddr & SEASTORE_OFF_MASK); + device_off_t get_device_off() const { + return decode_device_off(internal_paddr); } - void set_seastore_off(seastore_off_t off) { - assert(has_seastore_off(get_device_id())); + void set_device_off(device_off_t off) { + assert(has_device_off(get_device_id())); + assert(off >= DEVICE_OFF_MIN); + assert(off <= DEVICE_OFF_MAX); internal_paddr = (internal_paddr & DEVICE_ID_MASK); - internal_paddr |= static_cast(off); + internal_paddr |= encode_device_off(off); } - paddr_t add_offset(seastore_off_t o) const { - assert(has_seastore_off(get_device_id())); - auto off = get_seastore_off() + o; - assert(o >= 0 ? off >= get_seastore_off() : off < get_seastore_off()); + paddr_t add_offset(device_off_t o) const { + assert(has_device_off(get_device_id())); + assert(o >= DEVICE_OFF_MIN); + assert(o <= DEVICE_OFF_MAX); + auto off = get_device_off() + o; return paddr_t::make_res_paddr(get_device_id(), off); } paddr_t block_relative_to(const res_paddr_t &rhs) const { assert(rhs.is_record_relative() && is_record_relative()); - auto off = get_seastore_off() - rhs.get_seastore_off(); - assert(rhs.get_seastore_off() >= 0 ? - off <= get_seastore_off() : off > get_seastore_off()); + auto off = get_device_off() - rhs.get_device_off(); return paddr_t::make_res_paddr(DEVICE_ID_BLOCK_RELATIVE, off); } }; -constexpr paddr_t P_ADDR_MIN = paddr_t::create_const(0, 0, 0); +constexpr paddr_t P_ADDR_MIN = paddr_t::create_const(0, 0); // P_ADDR_MAX == P_ADDR_NULL == paddr_t{} -constexpr paddr_t P_ADDR_MAX = paddr_t::create_const(DEVICE_ID_MAX, 0, 0); +constexpr paddr_t P_ADDR_MAX = paddr_t::create_const(DEVICE_ID_MAX, 0); constexpr paddr_t P_ADDR_NULL = P_ADDR_MAX; -constexpr paddr_t P_ADDR_ZERO = paddr_t::create_const(DEVICE_ID_ZERO, 0, 0); -constexpr paddr_t P_ADDR_ROOT = paddr_t::create_const(DEVICE_ID_ROOT, 0, 0); +constexpr paddr_t P_ADDR_ZERO = paddr_t::create_const(DEVICE_ID_ZERO, 0); +constexpr paddr_t P_ADDR_ROOT = paddr_t::create_const(DEVICE_ID_ROOT, 0); -inline paddr_t make_record_relative_paddr(seastore_off_t off) { +inline paddr_t make_record_relative_paddr(device_off_t off) { return paddr_t::make_res_paddr(DEVICE_ID_RECORD_RELATIVE, off); } -inline paddr_t make_block_relative_paddr(seastore_off_t off) { +inline paddr_t make_block_relative_paddr(device_off_t off) { return paddr_t::make_res_paddr(DEVICE_ID_BLOCK_RELATIVE, off); } -inline paddr_t make_fake_paddr(seastore_off_t off) { +inline paddr_t make_fake_paddr(device_off_t off) { return paddr_t::make_res_paddr(DEVICE_ID_FAKE, off); } -inline paddr_t make_delayed_temp_paddr(seastore_off_t off) { +inline paddr_t make_delayed_temp_paddr(device_off_t off) { return paddr_t::make_res_paddr(DEVICE_ID_DELAYED, off); } @@ -816,15 +828,15 @@ inline res_paddr_t& paddr_t::as_res_paddr() { inline paddr_t::paddr_t(internal_paddr_t val) : internal_paddr(val) { #ifndef NDEBUG - auto type = device_id_to_paddr_type(get_device_id()); + auto type = get_addr_type(); if (type == paddr_types_t::SEGMENT) { assert(as_seg_paddr().get_segment_off() >= 0); } else if (type == paddr_types_t::RANDOM_BLOCK) { - // nothing to check + assert(as_blk_paddr().get_device_off() >= 0); } else { assert(type == paddr_types_t::RESERVED); - if (!has_seastore_off(get_device_id())) { - assert((internal_paddr & SEASTORE_OFF_MASK) == 0); + if (!has_device_off(get_device_id())) { + assert(as_res_paddr().get_device_off() == 0); } } #endif @@ -835,7 +847,7 @@ inline paddr_t::paddr_t(internal_paddr_t val) : internal_paddr(val) { return static_cast(this)->func; \ } -inline paddr_t paddr_t::add_offset(seastore_off_t o) const { +inline paddr_t paddr_t::add_offset(device_off_t o) const { PADDR_OPERATION(paddr_types_t::SEGMENT, seg_paddr_t, add_offset(o)) PADDR_OPERATION(paddr_types_t::RANDOM_BLOCK, blk_paddr_t, add_offset(o)) PADDR_OPERATION(paddr_types_t::RESERVED, res_paddr_t, add_offset(o)) @@ -846,7 +858,7 @@ inline paddr_t paddr_t::add_offset(seastore_off_t o) const { inline paddr_t paddr_t::add_relative(paddr_t o) const { assert(o.is_relative()); auto &res_o = o.as_res_paddr(); - return add_offset(res_o.get_seastore_off()); + return add_offset(res_o.get_device_off()); } inline paddr_t paddr_t::block_relative_to(paddr_t rhs) const { @@ -935,14 +947,14 @@ struct journal_seq_t { journal_seq_t add_offset( journal_type_t type, device_off_t off, - seastore_off_t roll_start, - seastore_off_t roll_size) const; + device_off_t roll_start, + device_off_t roll_size) const; device_off_t relative_to( journal_type_t type, const journal_seq_t& r, - seastore_off_t roll_start, - seastore_off_t roll_size) const; + device_off_t roll_start, + device_off_t roll_size) const; DENC(journal_seq_t, v, p) { DENC_START(1, 1, p); @@ -965,17 +977,17 @@ private: } else if (segment_seq < other.segment_seq) { return -1; } - using ret_t = std::pair; + using ret_t = std::pair; auto to_pair = [](const paddr_t &addr) -> ret_t { if (addr.get_addr_type() == paddr_types_t::SEGMENT) { auto &seg_addr = addr.as_seg_paddr(); return ret_t(seg_addr.get_segment_off(), seg_addr.get_segment_id()); } else if (addr.get_addr_type() == paddr_types_t::RANDOM_BLOCK) { auto &blk_addr = addr.as_blk_paddr(); - return ret_t(blk_addr.get_block_off(), MAX_SEG_ID); + return ret_t(blk_addr.get_device_off(), MAX_SEG_ID); } else if (addr.get_addr_type() == paddr_types_t::RESERVED) { auto &res_addr = addr.as_res_paddr(); - return ret_t(res_addr.get_seastore_off(), MAX_SEG_ID); + return ret_t(res_addr.get_device_off(), MAX_SEG_ID); } else { assert(0 == "impossible"); return ret_t(0, MAX_SEG_ID); diff --git a/src/crimson/os/seastore/transaction.h b/src/crimson/os/seastore/transaction.h index b5508fdb30f5..0f5f31f277d7 100644 --- a/src/crimson/os/seastore/transaction.h +++ b/src/crimson/os/seastore/transaction.h @@ -451,8 +451,8 @@ private: RootBlockRef root; ///< ref to root if read or written by transaction - seastore_off_t offset = 0; ///< relative offset of next block - seastore_off_t delayed_temp_offset = 0; + device_off_t offset = 0; ///< relative offset of next block + device_off_t delayed_temp_offset = 0; /** * read_set diff --git a/src/crimson/os/seastore/transaction_manager.cc b/src/crimson/os/seastore/transaction_manager.cc index 3b7812d48cc4..103ed8437294 100644 --- a/src/crimson/os/seastore/transaction_manager.cc +++ b/src/crimson/os/seastore/transaction_manager.cc @@ -642,8 +642,8 @@ TransactionManagerRef make_transaction_manager( } auto journal_type = p_backend_type; - seastore_off_t roll_size; - seastore_off_t roll_start; + device_off_t roll_size; + device_off_t roll_start; if (journal_type == journal_type_t::SEGMENTED) { roll_size = static_cast(primary_device)->get_segment_size(); roll_start = 0; @@ -654,6 +654,9 @@ TransactionManagerRef make_transaction_manager( // see CircularBoundedJournal::get_start_addr() roll_start = journal::CBJOURNAL_START_ADDRESS + primary_device->get_block_size(); + ceph_assert_always(roll_size <= DEVICE_OFF_MAX); + ceph_assert_always((std::size_t)roll_size + roll_start <= + primary_device->get_available_size()); } ceph_assert(roll_size % primary_device->get_block_size() == 0); ceph_assert(roll_start % primary_device->get_block_size() == 0); diff --git a/src/test/crimson/seastore/test_btree_lba_manager.cc b/src/test/crimson/seastore/test_btree_lba_manager.cc index 0718ca722953..bddb5a13ed93 100644 --- a/src/test/crimson/seastore/test_btree_lba_manager.cc +++ b/src/test/crimson/seastore/test_btree_lba_manager.cc @@ -415,7 +415,7 @@ struct btree_lba_manager_test : btree_test_base { ); } - seastore_off_t next_off = 0; + device_off_t next_off = 0; paddr_t get_paddr() { next_off += block_size; return make_fake_paddr(next_off); diff --git a/src/test/crimson/seastore/transaction_manager_test_state.h b/src/test/crimson/seastore/transaction_manager_test_state.h index 575601e26af5..7f383f71a30e 100644 --- a/src/test/crimson/seastore/transaction_manager_test_state.h +++ b/src/test/crimson/seastore/transaction_manager_test_state.h @@ -118,7 +118,8 @@ protected: { auto config = journal::CircularBoundedJournal::mkfs_config_t::get_default(); - rb_device.reset(new random_block_device::TestMemory(config.total_size)); + rb_device.reset(new random_block_device::TestMemory( + config.total_size + config.block_size)); rb_device->set_device_id( 1 << (std::numeric_limits::digits - 1)); return rb_device->mount().handle_error(crimson::ct_error::assert_all{}