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 <yingxin.cheng@intel.com>

diff --git a/src/crimson/os/seastore/async_cleaner.cc b/src/crimson/os/seastore/async_cleaner.cc
index 481b98b9ad642f701a7fece23835c17b020706f7..322f54ee3d9c8ae7d24c06e68b1f6abfb6535538 100644 (file)
--- 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 343d78bd7a568e3e816756a6a22c29eb035120a8..ded2a3da8ac1e7ff1c26f1d2bc6223c5f723f182 100644 (file)
--- 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<JournalTrimmerImpl>(
         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 ae2da76527eaddf7bd7a399d60ee7d2c22583d48..5c47001e77976722e24bce9fd8ff7984c49eb832 100644 (file)
--- 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 e6fc09834f5928c644f61e82bfd5f970c7897881..722685e80a47f303f780771a26a730e0d1488edd 100644 (file)
--- 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 32f447bcf18ed08d1a1e1a13f0318e1dc5359d5f..becc16ce6d2810c653031fb324f9e1e7f7fdb43b 100644 (file)
--- 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<device_off_t>(r.offset.as_seg_paddr().get_segment_off()));
   } else {
     assert(type == journal_type_t::RANDOM_BLOCK);
-    ret += (static_cast<device_off_t>(offset.as_blk_paddr().get_block_off()) -
-            static_cast<device_off_t>(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 14640da65502062edf7649cb50198822abb27452..5f2f3341e2a3255a625614397343a867386e8bbf 100644 (file)
--- 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<device_off_t>::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<internal_paddr_t>(BLOCK_OFF_MAX);
+  ((internal_paddr_t(1) << DEVICE_ID_BITS) - 1) << DEVICE_OFF_BITS;
+constexpr auto DEVICE_OFF_MASK =
+  std::numeric_limits<u_device_off_t>::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<internal_paddr_t>(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<device_off_t>(addr | DEVICE_ID_MASK);
+  } else {
+    return static_cast<device_off_t>(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<device_id_t>(internal_paddr >> BLOCK_OFF_BITS);
+    return static_cast<device_id_t>(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<internal_paddr_t>(seg.segment) << SEGMENT_OFF_BITS) |
               static_cast<u_segment_off_t>(offset)) {}
 
-  // as blk
-  paddr_t(device_id_t d_id, block_off_t offset)
-    : paddr_t((static_cast<internal_paddr_t>(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<internal_paddr_t>(d_id) << BLOCK_OFF_BITS) |
-              static_cast<u_seastore_off_t>(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<internal_paddr_t>(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<internal_paddr_t>(d_id) << BLOCK_OFF_BITS) |
-                     (static_cast<internal_paddr_t>(s_id) << SEGMENT_OFF_BITS) |
-                     static_cast<u_seastore_off_t>(offset)) {}
+                     static_cast<u_device_off_t>(offset)) {}
 
   friend struct paddr_le_t;
 };
@@ -700,7 +709,7 @@ struct seg_paddr_t : public paddr_t {
     internal_paddr |= static_cast<u_segment_off_t>(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<u_seastore_off_t>(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<const base*>(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<int64_t, segment_id_t>;
+    using ret_t = std::pair<device_off_t, segment_id_t>;
     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 b5508fdb30f5375e3a7384a9c78b6c2c1211c104..0f5f31f277d7c4601fda20e7fd39a1de489d8a59 100644 (file)
--- 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 3b7812d48cc450f71e89779dd53f908d73d54d59..103ed84372949f806b4f00c1fd1533c2cdc3dfd6 100644 (file)
--- 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<SegmentManager*>(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 0718ca7229536788f001f02fbdb58081c2cfe349..bddb5a13ed93530224210ed416b37931e0c64078 100644 (file)
--- 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 575601e26af5ab88b295a569a745088af7731aa5..7f383f71a30efb1751f96e63964477907ccb9867 100644 (file)
--- 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<device_id_t>::digits - 1));
     return rb_device->mount().handle_error(crimson::ct_error::assert_all{}