crimson/os/seastore: use segment_off_t for segment offsets

Segment offset has range from 32-bit signed integer.

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 a0a27a7ee286eb596c10baf937998a05ce418d9c..481b98b9ad642f701a7fece23835c17b020706f7 100644 (file)
--- a/src/crimson/os/seastore/async_cleaner.cc
+++ b/src/crimson/os/seastore/async_cleaner.cc
@@ -61,7 +61,7 @@ void segment_info_t::set_closed()
 void segment_info_t::init_closed(
     segment_seq_t _seq, segment_type_t _type,
     data_category_t _category, reclaim_gen_t _generation,
-    std::size_t seg_size)
+    segment_off_t seg_size)
 {
   ceph_assert(_seq != NULL_SEG_SEQ);
   ceph_assert(_type != segment_type_t::NULL_SEG);
@@ -144,7 +144,7 @@ void segments_info_t::add_segment_manager(
     ceph_assert(ssize > 0);
     segment_size = ssize;
   } else {
-    ceph_assert(segment_size == (std::size_t)ssize);
+    ceph_assert(segment_size == ssize);
   }
 
   // NOTE: by default the segments are empty
@@ -279,7 +279,7 @@ void segments_info_t::mark_closed(
   }
   ceph_assert(get_segment_size() >= segment_info.written_to);
   auto seg_avail_bytes = get_segment_size() - segment_info.written_to;
-  ceph_assert(avail_bytes_in_open >= seg_avail_bytes);
+  ceph_assert(avail_bytes_in_open >= (std::size_t)seg_avail_bytes);
   avail_bytes_in_open -= seg_avail_bytes;
 
   if (segment_info.modify_time != NULL_TIME) {
@@ -304,7 +304,7 @@ void segments_info_t::update_written_to(
     ceph_abort();
   }
 
-  auto new_written_to = static_cast<std::size_t>(saddr.get_segment_off());
+  auto new_written_to = saddr.get_segment_off();
   ceph_assert(new_written_to <= get_segment_size());
   if (segment_info.written_to > new_written_to) {
     ERROR("written_to should not decrease! type={}, offset={}, {}",
@@ -315,7 +315,7 @@ void segments_info_t::update_written_to(
   DEBUG("type={}, offset={}, {}", type, offset, segment_info);
   ceph_assert(type == segment_info.type);
   auto avail_deduction = new_written_to - segment_info.written_to;
-  ceph_assert(avail_bytes_in_open >= avail_deduction);
+  ceph_assert(avail_bytes_in_open >= (std::size_t)avail_deduction);
   avail_bytes_in_open -= avail_deduction;
   segment_info.written_to = new_written_to;
 }
@@ -687,7 +687,7 @@ bool SpaceTrackerSimple::equals(const SpaceTrackerI &_other) const
 
 int64_t SpaceTrackerDetailed::SegmentMap::allocate(
   device_segment_id_t segment,
-  seastore_off_t offset,
+  segment_off_t offset,
   extent_len_t len,
   const extent_len_t block_size)
 {
@@ -714,7 +714,7 @@ int64_t SpaceTrackerDetailed::SegmentMap::allocate(
 
 int64_t SpaceTrackerDetailed::SegmentMap::release(
   device_segment_id_t segment,
-  seastore_off_t offset,
+  segment_off_t offset,
   extent_len_t len,
   const extent_len_t block_size)
 {

diff --git a/src/crimson/os/seastore/async_cleaner.h b/src/crimson/os/seastore/async_cleaner.h
index 292ffd080752a1b89b7601540685ab6b6e9e8517..343d78bd7a568e3e816756a6a22c29eb035120a8 100644 (file)
--- a/src/crimson/os/seastore/async_cleaner.h
+++ b/src/crimson/os/seastore/async_cleaner.h
@@ -44,7 +44,7 @@ struct segment_info_t {
 
   std::size_t num_extents = 0;
 
-  std::size_t written_to = 0;
+  segment_off_t written_to = 0;
 
   bool is_in_journal(journal_seq_t tail_committed) const {
     return type == segment_type_t::JOURNAL &&
@@ -65,7 +65,7 @@ struct segment_info_t {
 
   void init_closed(segment_seq_t, segment_type_t,
                    data_category_t, reclaim_gen_t,
-                   std::size_t);
+                   segment_off_t);
 
   void set_open(segment_seq_t, segment_type_t,
                 data_category_t, reclaim_gen_t);
@@ -118,7 +118,7 @@ public:
     assert(segments.size() > 0);
     return segments.size();
   }
-  std::size_t get_segment_size() const {
+  segment_off_t get_segment_size() const {
     assert(segment_size > 0);
     return segment_size;
   }
@@ -239,7 +239,7 @@ private:
   // See reset() for member initialization
   segment_map_t<segment_info_t> segments;
 
-  std::size_t segment_size;
+  segment_off_t segment_size;
 
   segment_id_t journal_segment_id;
   std::size_t num_in_journal_open;
@@ -615,12 +615,12 @@ class SpaceTrackerI {
 public:
   virtual int64_t allocate(
     segment_id_t segment,
-    seastore_off_t offset,
+    segment_off_t offset,
     extent_len_t len) = 0;
 
   virtual int64_t release(
     segment_id_t segment,
-    seastore_off_t offset,
+    segment_off_t offset,
     extent_len_t len) = 0;
 
   virtual int64_t get_usage(
@@ -643,7 +643,7 @@ using SpaceTrackerIRef = std::unique_ptr<SpaceTrackerI>;
 class SpaceTrackerSimple : public SpaceTrackerI {
   struct segment_bytes_t {
     int64_t live_bytes = 0;
-    seastore_off_t total_bytes = 0;
+    segment_off_t total_bytes = 0;
   };
   // Tracks live space for each segment
   segment_map_t<segment_bytes_t> live_bytes_by_segment;
@@ -666,14 +666,14 @@ public:
 
   int64_t allocate(
     segment_id_t segment,
-    seastore_off_t offset,
+    segment_off_t offset,
     extent_len_t len) final {
     return update_usage(segment, len);
   }
 
   int64_t release(
     segment_id_t segment,
-    seastore_off_t offset,
+    segment_off_t offset,
     extent_len_t len) final {
     return update_usage(segment, -(int64_t)len);
   }
@@ -707,13 +707,13 @@ public:
 class SpaceTrackerDetailed : public SpaceTrackerI {
   class SegmentMap {
     int64_t used = 0;
-    seastore_off_t total_bytes = 0;
+    segment_off_t total_bytes = 0;
     std::vector<bool> bitmap;
 
   public:
     SegmentMap(
       size_t blocks,
-      seastore_off_t total_bytes)
+      segment_off_t total_bytes)
     : total_bytes(total_bytes),
       bitmap(blocks, false) {}
 
@@ -724,13 +724,13 @@ class SpaceTrackerDetailed : public SpaceTrackerI {
 
     int64_t allocate(
       device_segment_id_t segment,
-      seastore_off_t offset,
+      segment_off_t offset,
       extent_len_t len,
       const extent_len_t block_size);
 
     int64_t release(
       device_segment_id_t segment,
-      seastore_off_t offset,
+      segment_off_t offset,
       extent_len_t len,
       const extent_len_t block_size);
 
@@ -774,7 +774,7 @@ public:
 
   int64_t allocate(
     segment_id_t segment,
-    seastore_off_t offset,
+    segment_off_t offset,
     extent_len_t len) final {
     return segment_usage[segment].allocate(
       segment.device_segment_id(),
@@ -785,7 +785,7 @@ public:
 
   int64_t release(
     segment_id_t segment,
-    seastore_off_t offset,
+    segment_off_t offset,
     extent_len_t len) final {
     return segment_usage[segment].release(
       segment.device_segment_id(),
@@ -1077,14 +1077,14 @@ private:
   struct reclaim_state_t {
     reclaim_gen_t generation;
     reclaim_gen_t target_generation;
-    std::size_t segment_size;
+    segment_off_t segment_size;
     paddr_t start_pos;
     paddr_t end_pos;
 
     static reclaim_state_t create(
         segment_id_t segment_id,
         reclaim_gen_t generation,
-        std::size_t segment_size) {
+        segment_off_t segment_size) {
       ceph_assert(generation < RECLAIM_GENERATIONS);
       return {generation,
               (reclaim_gen_t)(generation == RECLAIM_GENERATIONS - 1 ?
@@ -1099,7 +1099,7 @@ private:
     }
 
     bool is_complete() const {
-      return (std::size_t)end_pos.as_seg_paddr().get_segment_off() >= segment_size;
+      return end_pos.as_seg_paddr().get_segment_off() >= segment_size;
     }
 
     void advance(std::size_t bytes) {
@@ -1107,7 +1107,7 @@ private:
       start_pos = end_pos;
       auto &end_seg_paddr = end_pos.as_seg_paddr();
       auto next_off = end_seg_paddr.get_segment_off() + bytes;
-      if (next_off > segment_size) {
+      if (next_off > (std::size_t)segment_size) {
         end_seg_paddr.set_segment_off(segment_size);
       } else {
         end_seg_paddr.set_segment_off(next_off);

diff --git a/src/crimson/os/seastore/journal/segment_allocator.h b/src/crimson/os/seastore/journal/segment_allocator.h
index 191f8180403de02d31338046426bcfd2f845507f..acafa5e0d2fbcb6306fc60e134d1b8bb62239647 100644 (file)
--- a/src/crimson/os/seastore/journal/segment_allocator.h
+++ b/src/crimson/os/seastore/journal/segment_allocator.h
@@ -69,7 +69,7 @@ class SegmentAllocator {
     return current_segment_nonce;
   }
 
-  seastore_off_t get_written_to() const {
+  segment_off_t get_written_to() const {
     assert(can_write());
     return written_to;
   }
@@ -126,7 +126,7 @@ class SegmentAllocator {
   SegmentProvider &segment_provider;
   SegmentManagerGroup &sm_group;
   SegmentRef current_segment;
-  seastore_off_t written_to;
+  segment_off_t written_to;
   SegmentSeqAllocator &segment_seq_allocator;
   segment_nonce_t current_segment_nonce;
   JournalTrimmer *trimmer;

diff --git a/src/crimson/os/seastore/seastore_types.cc b/src/crimson/os/seastore/seastore_types.cc
index 89543c5a5e913b3a612ae418e6a1fc71f8eb9f9b..32f447bcf18ed08d1a1e1a13f0318e1dc5359d5f 100644 (file)
--- a/src/crimson/os/seastore/seastore_types.cc
+++ b/src/crimson/os/seastore/seastore_types.cc
@@ -117,7 +117,7 @@ std::ostream &operator<<(std::ostream &out, const paddr_t &rhs)
     auto &s = rhs.as_seg_paddr();
     out << s.get_segment_id()
         << ","
-        << seastore_off_printer_t{s.get_segment_off()};
+        << s.get_segment_off();
   } else if (rhs.get_addr_type() == paddr_types_t::RANDOM_BLOCK) {
     auto &s = rhs.as_blk_paddr();
     out << device_id_printer_t{s.get_device_id()}

diff --git a/src/crimson/os/seastore/seastore_types.h b/src/crimson/os/seastore/seastore_types.h
index dcbff8e40e39f8e3cfeeacd36f4ac53f4561d34e..14640da65502062edf7649cb50198822abb27452 100644 (file)
--- a/src/crimson/os/seastore/seastore_types.h
+++ b/src/crimson/os/seastore/seastore_types.h
@@ -472,6 +472,16 @@ constexpr auto BLOCK_OFF_BITS = PADDR_BITS - DEVICE_ID_BITS;
 constexpr auto BLOCK_OFF_MAX =
     std::numeric_limits<block_off_t>::max() >> DEVICE_ID_BITS;
 
+/**
+ * segment_off_t
+ *
+ * Offset within a segment on disk, may be negative for relative offsets.
+ *
+ * TODO: replace seastore_off_t
+ */
+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 =
@@ -492,14 +502,14 @@ public:
 
   static paddr_t make_seg_paddr(
     segment_id_t seg,
-    seastore_off_t offset) {
+    segment_off_t offset) {
     return paddr_t(seg, offset);
   }
 
   static paddr_t make_seg_paddr(
     device_id_t device,
     device_segment_id_t seg,
-    seastore_off_t offset) {
+    segment_off_t offset) {
     return paddr_t(segment_id_t(device, seg), offset);
   }
 
@@ -638,9 +648,9 @@ protected:
 
 private:
   // as seg
-  paddr_t(segment_id_t seg, seastore_off_t offset)
+  paddr_t(segment_id_t seg, segment_off_t offset)
     : paddr_t((static_cast<internal_paddr_t>(seg.segment) << SEGMENT_OFF_BITS) |
-              static_cast<u_seastore_off_t>(offset)) {}
+              static_cast<u_segment_off_t>(offset)) {}
 
   // as blk
   paddr_t(device_id_t d_id, block_off_t offset)
@@ -680,20 +690,22 @@ struct seg_paddr_t : public paddr_t {
            internal_paddr >> SEGMENT_OFF_BITS));
   }
 
-  seastore_off_t get_segment_off() const {
-    return seastore_off_t(internal_paddr & SEGMENT_OFF_MASK);
+  segment_off_t get_segment_off() const {
+    return segment_off_t(internal_paddr & SEGMENT_OFF_MASK);
   }
 
-  void set_segment_off(seastore_off_t off) {
+  void set_segment_off(segment_off_t off) {
     assert(off >= 0);
     internal_paddr = (internal_paddr & SEGMENT_ID_MASK);
-    internal_paddr |= static_cast<u_seastore_off_t>(off);
+    internal_paddr |= static_cast<u_segment_off_t>(off);
   }
 
   paddr_t add_offset(seastore_off_t o) const {
-    auto off = get_segment_off() + o;
-    assert(o >= 0 ? off >= get_segment_off() : off < get_segment_off());
-    return paddr_t::make_seg_paddr(get_segment_id(), off);
+    device_off_t off = get_segment_off() + o;
+    assert(off >= 0);
+    assert(off <= MAX_SEG_OFF);
+    return paddr_t::make_seg_paddr(
+        get_segment_id(), static_cast<segment_off_t>(off));
   }
 };
 
@@ -2015,11 +2027,11 @@ struct scan_valid_records_cursor {
     return seq.offset.as_seg_paddr().get_segment_id();
   }
 
-  seastore_off_t get_segment_offset() const {
+  segment_off_t get_segment_offset() const {
     return seq.offset.as_seg_paddr().get_segment_off();
   }
 
-  void increment_seq(seastore_off_t off) {
+  void increment_seq(segment_off_t off) {
     auto& seg_addr = seq.offset.as_seg_paddr();
     seg_addr.set_segment_off(
       seg_addr.get_segment_off() + off);

diff --git a/src/crimson/os/seastore/segment_manager.h b/src/crimson/os/seastore/segment_manager.h
index a7941384c720a57429bd87fa4a3f29d6286a1c43..4c137a4fd919072a77679387d84cd78661ddd829 100644 (file)
--- a/src/crimson/os/seastore/segment_manager.h
+++ b/src/crimson/os/seastore/segment_manager.h
@@ -95,12 +95,12 @@ public:
   /**
    * min next write location
    */
-  virtual seastore_off_t get_write_ptr() const = 0;
+  virtual segment_off_t get_write_ptr() const = 0;
 
   /**
    * max capacity
    */
-  virtual seastore_off_t get_write_capacity() const = 0;
+  virtual segment_off_t get_write_capacity() const = 0;
 
   /**
    * close
@@ -129,7 +129,7 @@ public:
     crimson::ct_error::enospc              // write exceeds segment size
     >;
   virtual write_ertr::future<> write(
-    seastore_off_t offset, ceph::bufferlist bl) = 0;
+    segment_off_t offset, ceph::bufferlist bl) = 0;
 
   /**
    * advance_wp
@@ -139,7 +139,7 @@ public:
    * @param offset: advance write pointer till the given offset
    */
   virtual write_ertr::future<> advance_wp(
-    seastore_off_t offset) = 0;
+    segment_off_t offset) = 0;
 
   virtual ~Segment() {}
 };
@@ -175,7 +175,7 @@ public:
   virtual release_ertr::future<> release(segment_id_t id) = 0;
 
   /* Methods for discovering device geometry, segmentid set, etc */
-  virtual seastore_off_t get_segment_size() const = 0;
+  virtual segment_off_t get_segment_size() const = 0;
   virtual device_segment_id_t get_num_segments() const {
     ceph_assert(get_available_size() % get_segment_size() == 0);
     return ((device_segment_id_t)(get_available_size() / get_segment_size()));

diff --git a/src/crimson/os/seastore/segment_manager/block.cc b/src/crimson/os/seastore/segment_manager/block.cc
index 36be358bde68448399aa67e4b5da3c68516b4841..e6888ba813c16aab6f1238cc487118484ba5f3ce 100644 (file)
--- a/src/crimson/os/seastore/segment_manager/block.cc
+++ b/src/crimson/os/seastore/segment_manager/block.cc
@@ -386,7 +386,7 @@ BlockSegment::BlockSegment(
   BlockSegmentManager &manager, segment_id_t id)
   : manager(manager), id(id) {}
 
-seastore_off_t BlockSegment::get_write_capacity() const
+segment_off_t BlockSegment::get_write_capacity() const
 {
   return manager.get_segment_size();
 }
@@ -397,7 +397,7 @@ Segment::close_ertr::future<> BlockSegment::close()
 }
 
 Segment::write_ertr::future<> BlockSegment::write(
-  seastore_off_t offset, ceph::bufferlist bl)
+  segment_off_t offset, ceph::bufferlist bl)
 {
   LOG_PREFIX(BlockSegment::write);
   auto paddr = paddr_t::make_seg_paddr(id, offset);
@@ -424,12 +424,12 @@ Segment::write_ertr::future<> BlockSegment::write(
 }
 
 Segment::write_ertr::future<> BlockSegment::advance_wp(
-  seastore_off_t offset) {
+  segment_off_t offset) {
   return write_ertr::now();
 }
 
 Segment::close_ertr::future<> BlockSegmentManager::segment_close(
-    segment_id_t id, seastore_off_t write_pointer)
+    segment_id_t id, segment_off_t write_pointer)
 {
   LOG_PREFIX(BlockSegmentManager::segment_close);
   auto s_id = id.device_segment_id();

diff --git a/src/crimson/os/seastore/segment_manager/block.h b/src/crimson/os/seastore/segment_manager/block.h
index 6da39d38a51b940612d56ed5dcfcd4dc156ab330..0807534ab8427bb5135f2e16cad6d6c77ec41bf2 100644 (file)
--- a/src/crimson/os/seastore/segment_manager/block.h
+++ b/src/crimson/os/seastore/segment_manager/block.h
@@ -88,16 +88,16 @@ class BlockSegment final : public Segment {
   friend class BlockSegmentManager;
   BlockSegmentManager &manager;
   const segment_id_t id;
-  seastore_off_t write_pointer = 0;
+  segment_off_t write_pointer = 0;
 public:
   BlockSegment(BlockSegmentManager &manager, segment_id_t id);
 
   segment_id_t get_segment_id() const final { return id; }
-  seastore_off_t get_write_capacity() const final;
-  seastore_off_t get_write_ptr() const final { return write_pointer; }
+  segment_off_t get_write_capacity() const final;
+  segment_off_t get_write_ptr() const final { return write_pointer; }
   close_ertr::future<> close() final;
-  write_ertr::future<> write(seastore_off_t offset, ceph::bufferlist bl) final;
-  write_ertr::future<> advance_wp(seastore_off_t offset) final;
+  write_ertr::future<> write(segment_off_t offset, ceph::bufferlist bl) final;
+  write_ertr::future<> advance_wp(segment_off_t offset) final;
 
   ~BlockSegment() {}
 };
@@ -138,7 +138,7 @@ public:
   extent_len_t get_block_size() const {
     return superblock.block_size;
   }
-  seastore_off_t get_segment_size() const {
+  segment_off_t get_segment_size() const {
     return superblock.segment_size;
   }
 
@@ -225,7 +225,7 @@ private:
   char *buffer = nullptr;
 
   Segment::close_ertr::future<> segment_close(
-      segment_id_t id, seastore_off_t write_pointer);
+      segment_id_t id, segment_off_t write_pointer);
 };
 
 }

diff --git a/src/crimson/os/seastore/segment_manager/ephemeral.cc b/src/crimson/os/seastore/segment_manager/ephemeral.cc
index 7c2f5759926d0a691da0a008f0fd371920b88f6e..f8a20167fb75c3d6a55c422f1b68ff5037db9f97 100644 (file)
--- a/src/crimson/os/seastore/segment_manager/ephemeral.cc
+++ b/src/crimson/os/seastore/segment_manager/ephemeral.cc
@@ -63,7 +63,7 @@ EphemeralSegment::EphemeralSegment(
   EphemeralSegmentManager &manager, segment_id_t id)
   : manager(manager), id(id) {}
 
-seastore_off_t EphemeralSegment::get_write_capacity() const
+segment_off_t EphemeralSegment::get_write_capacity() const
 {
   return manager.get_segment_size();
 }
@@ -76,7 +76,7 @@ Segment::close_ertr::future<> EphemeralSegment::close()
 }
 
 Segment::write_ertr::future<> EphemeralSegment::write(
-  seastore_off_t offset, ceph::bufferlist bl)
+  segment_off_t offset, ceph::bufferlist bl)
 {
   if (offset < write_pointer || offset % manager.config.block_size != 0)
     return crimson::ct_error::invarg::make();
@@ -88,7 +88,7 @@ Segment::write_ertr::future<> EphemeralSegment::write(
 }
 
 Segment::write_ertr::future<> EphemeralSegment::advance_wp(
-  seastore_off_t offset)
+  segment_off_t offset)
 {
   return write_ertr::now();
 }

diff --git a/src/crimson/os/seastore/segment_manager/ephemeral.h b/src/crimson/os/seastore/segment_manager/ephemeral.h
index a9a235384864ec368dfc59144b3a3c8f56d06c79..e98ed691cbf9840910a258183afbc86884246e4a 100644 (file)
--- a/src/crimson/os/seastore/segment_manager/ephemeral.h
+++ b/src/crimson/os/seastore/segment_manager/ephemeral.h
@@ -48,16 +48,16 @@ class EphemeralSegment final : public Segment {
   friend class EphemeralSegmentManager;
   EphemeralSegmentManager &manager;
   const segment_id_t id;
-  seastore_off_t write_pointer = 0;
+  segment_off_t write_pointer = 0;
 public:
   EphemeralSegment(EphemeralSegmentManager &manager, segment_id_t id);
 
   segment_id_t get_segment_id() const final { return id; }
-  seastore_off_t get_write_capacity() const final;
-  seastore_off_t get_write_ptr() const final { return write_pointer; }
+  segment_off_t get_write_capacity() const final;
+  segment_off_t get_write_ptr() const final { return write_pointer; }
   close_ertr::future<> close() final;
-  write_ertr::future<> write(seastore_off_t offset, ceph::bufferlist bl) final;
-  write_ertr::future<> advance_wp(seastore_off_t offset) final;
+  write_ertr::future<> write(segment_off_t offset, ceph::bufferlist bl) final;
+  write_ertr::future<> advance_wp(segment_off_t offset) final;
 
   ~EphemeralSegment() {}
 };
@@ -120,7 +120,7 @@ public:
   extent_len_t get_block_size() const final {
     return config.block_size;
   }
-  seastore_off_t get_segment_size() const final {
+  segment_off_t get_segment_size() const final {
     return config.segment_size;
   }
 

diff --git a/src/crimson/os/seastore/segment_manager/zns.cc b/src/crimson/os/seastore/segment_manager/zns.cc
index 8252654204af7d4965170fd7aaac5b81435c35ea..ac1519bbf8dbc10f021ce3da00a88f68111c8b61 100644 (file)
--- a/src/crimson/os/seastore/segment_manager/zns.cc
+++ b/src/crimson/os/seastore/segment_manager/zns.cc
@@ -573,7 +573,7 @@ SegmentManager::read_ertr::future<> ZNSSegmentManager::read(
 }
 
 Segment::close_ertr::future<> ZNSSegmentManager::segment_close(
-  segment_id_t id, seastore_off_t write_pointer)
+  segment_id_t id, segment_off_t write_pointer)
 {
   LOG_PREFIX(ZNSSegmentManager::segment_close);
   return seastar::do_with(
@@ -631,7 +631,7 @@ magic_t ZNSSegmentManager::get_magic() const
   return metadata.magic;
 };
 
-seastore_off_t ZNSSegment::get_write_capacity() const
+segment_off_t ZNSSegment::get_write_capacity() const
 {
   return manager.get_segment_size();
 }
@@ -650,7 +650,7 @@ Segment::close_ertr::future<> ZNSSegment::close()
 }
 
 Segment::write_ertr::future<> ZNSSegment::write(
-  seastore_off_t offset, ceph::bufferlist bl)
+  segment_off_t offset, ceph::bufferlist bl)
 {
   LOG_PREFIX(ZNSSegment::write);
   if (offset != write_pointer || offset % manager.metadata.block_size != 0) {
@@ -699,7 +699,7 @@ Segment::write_ertr::future<> ZNSSegment::write_padding_bytes(
 
 // Advance write pointer, to given offset.
 Segment::write_ertr::future<> ZNSSegment::advance_wp(
-  seastore_off_t offset)
+  segment_off_t offset)
 {
   LOG_PREFIX(ZNSSegment::advance_wp);
 

diff --git a/src/crimson/os/seastore/segment_manager/zns.h b/src/crimson/os/seastore/segment_manager/zns.h
index 574fe92aaf1794a75d6f2bc69ab06efb7a04900e..65e0d213ad672784b5feefafb09a9a643cd078dc 100644 (file)
--- a/src/crimson/os/seastore/segment_manager/zns.h
+++ b/src/crimson/os/seastore/segment_manager/zns.h
@@ -79,18 +79,18 @@ namespace crimson::os::seastore::segment_manager::zns {
     ZNSSegment(ZNSSegmentManager &man, segment_id_t i) : manager(man), id(i){};
 
     segment_id_t get_segment_id() const final { return id; }
-    seastore_off_t get_write_capacity() const final;
-    seastore_off_t get_write_ptr() const final { return write_pointer; }
+    segment_off_t get_write_capacity() const final;
+    segment_off_t get_write_ptr() const final { return write_pointer; }
     close_ertr::future<> close() final;
-    write_ertr::future<> write(seastore_off_t offset, ceph::bufferlist bl) final;
-    write_ertr::future<> advance_wp(seastore_off_t offset) final;
+    write_ertr::future<> write(segment_off_t offset, ceph::bufferlist bl) final;
+    write_ertr::future<> advance_wp(segment_off_t offset) final;
 
     ~ZNSSegment() {}
   private:
     friend class ZNSSegmentManager;
     ZNSSegmentManager &manager;
     const segment_id_t id;
-    seastore_off_t write_pointer = 0;
+    segment_off_t write_pointer = 0;
     write_ertr::future<> write_padding_bytes(size_t padding_bytes);
   };
 
@@ -116,7 +116,7 @@ namespace crimson::os::seastore::segment_manager::zns {
       return metadata.block_size;
     };
 
-    seastore_off_t get_segment_size() const final {
+    segment_off_t get_segment_size() const final {
       return metadata.segment_capacity;
     };
 
@@ -173,7 +173,7 @@ namespace crimson::os::seastore::segment_manager::zns {
     seastar::metrics::metric_group metrics;
 
     Segment::close_ertr::future<> segment_close(
-      segment_id_t id, seastore_off_t write_pointer);
+      segment_id_t id, segment_off_t write_pointer);
 
     uint64_t get_offset(paddr_t addr) {
       auto& seg_addr = addr.as_seg_paddr();

diff --git a/src/crimson/os/seastore/segment_manager_group.h b/src/crimson/os/seastore/segment_manager_group.h
index d5b22f436df991b84d250d46084da0c0382cbb3b..9a5729515b8db8ad037d4f45b41a3241a5ee9d2a 100644 (file)
--- a/src/crimson/os/seastore/segment_manager_group.h
+++ b/src/crimson/os/seastore/segment_manager_group.h
@@ -55,7 +55,7 @@ public:
     return segment_managers[*device_ids.begin()]->get_block_size();
   }
 
-  seastore_off_t get_segment_size() const {
+  segment_off_t get_segment_size() const {
     assert(device_ids.size());
     return segment_managers[*device_ids.begin()]->get_segment_size();
   }

diff --git a/src/test/crimson/seastore/test_seastore_cache.cc b/src/test/crimson/seastore/test_seastore_cache.cc
index 53e5563a417efae677a4d7b97802bb0e5bdeadea..3ed2462a43f895d25cbaf96fa132f527d9d8fcd4 100644 (file)
--- a/src/test/crimson/seastore/test_seastore_cache.cc
+++ b/src/test/crimson/seastore/test_seastore_cache.cc
@@ -37,9 +37,9 @@ struct cache_test_t : public seastar_test_suite_t {
       bl.append(block.bl);
     }
 
-    ceph_assert((seastore_off_t)bl.length() <
+    ceph_assert((segment_off_t)bl.length() <
                segment_manager->get_segment_size());
-    if (current.as_seg_paddr().get_segment_off() + (seastore_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::make_seg_paddr(
        segment_id_t(

diff --git a/src/test/crimson/seastore/transaction_manager_test_state.h b/src/test/crimson/seastore/transaction_manager_test_state.h
index 0c45dcc61138c71e2a1057ac7b7f36c9ee27fe79..575601e26af5ab88b295a569a745088af7731aa5 100644 (file)
--- a/src/test/crimson/seastore/transaction_manager_test_state.h
+++ b/src/test/crimson/seastore/transaction_manager_test_state.h
@@ -326,7 +326,7 @@ public:
 
   size_t get_available_size() const final { return sm.get_available_size(); }
   extent_len_t get_block_size() const final { return sm.get_block_size(); }
-  seastore_off_t get_segment_size() const final {
+  segment_off_t get_segment_size() const final {
     return sm.get_segment_size();
   }
   const seastore_meta_t &get_meta() const final {