crimson/os/seastore: replace out_of_line by segment_type_t

Leverage segment_seq_t to identify the type of the segment.

Signed-off-by: Yingxin Cheng <yingxin.cheng@intel.com>

diff --git a/src/crimson/os/seastore/extent_placement_manager.cc b/src/crimson/os/seastore/extent_placement_manager.cc
index 217ccdb840003b073b98402c660410a71b99c830..be35bb09b428f3a5887870a709cf1ec958a502c7 100644 (file)
--- a/src/crimson/os/seastore/extent_placement_manager.cc
+++ b/src/crimson/os/seastore/extent_placement_manager.cc
@@ -200,7 +200,7 @@ SegmentedAllocator::Writer::init_segment(Segment& segment) {
   auto header =segment_header_t{
     OOL_SEG_SEQ,
     segment.get_segment_id(),
-    NO_DELTAS, 0, true};
+    NO_DELTAS, 0};
   logger().debug("SegmentedAllocator::Writer::init_segment: initting {}, {}",
     segment.get_segment_id(),
     header);

diff --git a/src/crimson/os/seastore/journal.cc b/src/crimson/os/seastore/journal.cc
index 576790e55b933a527b94d5eb852c929cf015ac69..b742bec0a026eee8e4d3a86b3045d0320abe5e1f 100644 (file)
--- a/src/crimson/os/seastore/journal.cc
+++ b/src/crimson/os/seastore/journal.cc
@@ -94,7 +94,7 @@ Journal::prep_replay_segments(
   {
     if (seg.first != seg.second.physical_segment_id ||
         seg.first.device_id() != journal_segment_manager.get_device_id() ||
-        seg.second.out_of_line == true) {
+        seg.second.get_type() != segment_type_t::JOURNAL) {
       ERROR("illegal journal segment for replay -- {}", seg.second);
       ceph_abort();
     }
@@ -206,9 +206,10 @@ Journal::replay_segment(
             if (delta.paddr != P_ADDR_NULL) {
               auto& seg_addr = delta.paddr.as_seg_paddr();
               auto delta_paddr_segment_seq = segment_provider->get_seq(seg_addr.get_segment_id());
+              auto delta_paddr_segment_type = segment_seq_to_type(delta_paddr_segment_seq);
               auto locator_segment_seq = locator.write_result.start_seq.segment_seq;
-              if (delta_paddr_segment_seq == NULL_SEG_SEQ ||
-                  (delta_paddr_segment_seq <= MAX_VALID_SEG_SEQ &&
+              if (delta_paddr_segment_type == segment_type_t::NULL_SEG ||
+                  (delta_paddr_segment_type == segment_type_t::JOURNAL &&
                    delta_paddr_segment_seq > locator_segment_seq)) {
                 return replay_ertr::now();
               }
@@ -460,9 +461,9 @@ Journal::JournalSegmentManager::initialize_segment(Segment& segment)
     seq,
     segment.get_segment_id(),
     new_tail,
-    current_segment_nonce,
-    false};
+    current_segment_nonce};
   INFO("writing {} ...", header);
+  ceph_assert(header.get_type() == segment_type_t::JOURNAL);
   encode(header, bl);
 
   bufferptr bp(

diff --git a/src/crimson/os/seastore/seastore_types.cc b/src/crimson/os/seastore/seastore_types.cc
index 185c88378ddd2a36cb342ca5f1231e4ae7bfbffb..0dc3fe9a8cd4bd0e49910a17014a63a60259b475 100644 (file)
--- a/src/crimson/os/seastore/seastore_types.cc
+++ b/src/crimson/os/seastore/seastore_types.cc
@@ -42,6 +42,43 @@ std::ostream &offset_to_stream(std::ostream &out, const seastore_off_t &t)
     return out << t;
 }
 
+std::ostream& operator<<(std::ostream& out, segment_type_t t)
+{
+  switch(t) {
+  case segment_type_t::JOURNAL:
+    return out << "JOURNAL";
+  case segment_type_t::OOL:
+    return out << "OOL";
+  case segment_type_t::NULL_SEG:
+    return out << "NULL_SEG";
+  default:
+    return out << "INVALID_SEGMENT_TYPE!";
+  }
+}
+
+segment_type_t segment_seq_to_type(segment_seq_t seq)
+{
+  if (seq <= MAX_VALID_SEG_SEQ) {
+    return segment_type_t::JOURNAL;
+  } else if (seq == OOL_SEG_SEQ) {
+    return segment_type_t::OOL;
+  } else {
+    assert(seq == NULL_SEG_SEQ);
+    return segment_type_t::NULL_SEG;
+  }
+}
+
+std::ostream& operator<<(std::ostream& out, segment_seq_printer_t seq)
+{
+  auto type = segment_seq_to_type(seq.seq);
+  switch(type) {
+  case segment_type_t::JOURNAL:
+    return out << seq.seq;
+  default:
+    return out << type;
+  }
+}
+
 std::ostream &operator<<(std::ostream &out, const segment_id_t& segment)
 {
   return out << "[" << (uint64_t)segment.device_id() << ","
@@ -83,7 +120,7 @@ std::ostream &operator<<(std::ostream &out, const paddr_t &rhs)
 std::ostream &operator<<(std::ostream &out, const journal_seq_t &seq)
 {
   return out << "journal_seq_t("
-             << "segment_seq=" << seq.segment_seq
+             << "segment_seq=" << segment_seq_printer_t{seq.segment_seq}
              << ", offset=" << seq.offset
              << ")";
 }
@@ -164,11 +201,10 @@ std::ostream &operator<<(std::ostream &out, const extent_info_t &info)
 std::ostream &operator<<(std::ostream &out, const segment_header_t &header)
 {
   return out << "segment_header_t("
-            << "segment_seq=" << header.journal_segment_seq
+            << "segment_seq=" << segment_seq_printer_t{header.journal_segment_seq}
             << ", segment_id=" << header.physical_segment_id
             << ", journal_tail=" << header.journal_tail
             << ", segment_nonce=" << header.segment_nonce
-            << ", out-of-line=" << header.out_of_line
             << ")";
 }
 

diff --git a/src/crimson/os/seastore/seastore_types.h b/src/crimson/os/seastore/seastore_types.h
index a9b895fd58bf8fc97a8f29e607dfbb206ba90b48..ecb42c29ad14b1d23262342eae477ce78caca628 100644 (file)
--- a/src/crimson/os/seastore/seastore_types.h
+++ b/src/crimson/os/seastore/seastore_types.h
@@ -197,6 +197,22 @@ static constexpr segment_seq_t NULL_SEG_SEQ = MAX_SEG_SEQ;
 static constexpr segment_seq_t OOL_SEG_SEQ = MAX_SEG_SEQ - 1;
 static constexpr segment_seq_t MAX_VALID_SEG_SEQ = MAX_SEG_SEQ - 2;
 
+enum class segment_type_t {
+  JOURNAL = 0,
+  OOL,
+  NULL_SEG,
+};
+
+std::ostream& operator<<(std::ostream& out, segment_type_t t);
+
+segment_type_t segment_seq_to_type(segment_seq_t seq);
+
+struct segment_seq_printer_t {
+  segment_seq_t seq;
+};
+
+std::ostream& operator<<(std::ostream& out, segment_seq_printer_t seq);
+
 // Offset of delta within a record
 using record_delta_idx_t = uint32_t;
 constexpr record_delta_idx_t NULL_DELTA_IDX =
@@ -728,6 +744,10 @@ struct journal_seq_t {
     return {segment_seq, offset.add_offset(o)};
   }
 
+  segment_type_t get_type() const {
+    return segment_seq_to_type(segment_seq);
+  }
+
   DENC(journal_seq_t, v, p) {
     DENC_START(1, 1, p);
     denc(v.segment_seq, p);
@@ -1244,7 +1264,10 @@ struct segment_header_t {
 
   journal_seq_t journal_tail;
   segment_nonce_t segment_nonce;
-  bool out_of_line;
+
+  segment_type_t get_type() const {
+    return segment_seq_to_type(journal_segment_seq);
+  }
 
   DENC(segment_header_t, v, p) {
     DENC_START(1, 1, p);
@@ -1252,7 +1275,6 @@ struct segment_header_t {
     denc(v.physical_segment_id, p);
     denc(v.journal_tail, p);
     denc(v.segment_nonce, p);
-    denc(v.out_of_line, p);
     DENC_FINISH(p);
   }
 };

diff --git a/src/crimson/os/seastore/segment_cleaner.cc b/src/crimson/os/seastore/segment_cleaner.cc
index cd9f88c9f64b5625e7a38a5f0e02fc86eb87af5d..e0ccd19026ad5bc4bee0068e6e7e29e8a5c8fc8b 100644 (file)
--- a/src/crimson/os/seastore/segment_cleaner.cc
+++ b/src/crimson/os/seastore/segment_cleaner.cc
@@ -436,24 +436,22 @@ SegmentCleaner::init_segments_ret SegmentCleaner::init_segments() {
        return scanner->read_segment_header(
          segment_id
        ).safe_then([&segment_set, segment_id, this](auto header) {
-         if (header.out_of_line) {
-           logger().debug(
-             "ExtentReader::init_segments: out-of-line segment {}",
-             segment_id);
-           init_mark_segment_closed(
-             segment_id,
-             header.journal_segment_seq,
-             true);
-         } else {
-           logger().debug(
-             "ExtentReader::init_segments: journal segment {}",
-             segment_id);
+         logger().debug(
+           "ExtentReader::init_segments: segment_id={} -- {}",
+           segment_id, header);
+         auto s_type = header.get_type();
+         if (s_type == segment_type_t::NULL_SEG) {
+           logger().error(
+             "ExtentReader::init_segments: got null segment, segment_id={} -- {}",
+             segment_id, header);
+           ceph_abort();
+         }
+         if (s_type == segment_type_t::JOURNAL) {
            segment_set.emplace_back(std::make_pair(segment_id, std::move(header)));
-           init_mark_segment_closed(
-             segment_id,
-             header.journal_segment_seq,
-             false);
          }
+         init_mark_segment_closed(
+           segment_id,
+           header.journal_segment_seq);
        }).handle_error(
          crimson::ct_error::enoent::handle([](auto) {
            return init_segments_ertr::now();

diff --git a/src/crimson/os/seastore/segment_cleaner.h b/src/crimson/os/seastore/segment_cleaner.h
index 795f7c02316b1b319710576cad60cb56dd964011..3d0168dd380968a30f6ddad2c7b2d89a16612bd3 100644 (file)
--- a/src/crimson/os/seastore/segment_cleaner.h
+++ b/src/crimson/os/seastore/segment_cleaner.h
@@ -57,16 +57,17 @@ class segment_info_set_t {
     // Will be non-null for any segments in the current journal
     segment_seq_t journal_segment_seq = NULL_SEG_SEQ;
 
-    bool out_of_line = false;
+    segment_type_t get_type() const {
+      return segment_seq_to_type(journal_segment_seq);
+    }
 
     void set_open();
     void set_empty();
     void set_closed();
 
     bool is_in_journal(journal_seq_t tail_committed) const {
-      return !out_of_line &&
-       journal_segment_seq != NULL_SEG_SEQ &&
-       tail_committed.segment_seq <= journal_segment_seq;
+      return get_type() == segment_type_t::JOURNAL &&
+             tail_committed.segment_seq <= journal_segment_seq;
     }
 
     bool is_empty() const {
@@ -1257,16 +1258,16 @@ private:
 
   void init_mark_segment_closed(
     segment_id_t segment,
-    segment_seq_t seq,
-    bool out_of_line) {
+    segment_seq_t seq) {
     crimson::get_logger(ceph_subsys_seastore_cleaner).debug(
       "SegmentCleaner::init_mark_segment_closed: segment {}, seq {}",
       segment,
-      seq);
+      segment_seq_printer_t{seq});
     mark_closed(segment);
     segments[segment].journal_segment_seq = seq;
-    segments[segment].out_of_line = out_of_line;
-    if (!segments[segment].out_of_line) {
+    auto s_type = segments[segment].get_type();
+    assert(s_type != segment_type_t::NULL_SEG);
+    if (s_type == segment_type_t::JOURNAL) {
       assert(journal_device_id == segment.device_id());
       segments.new_journal_segment();
     }
@@ -1322,7 +1323,9 @@ private:
        should_block_on_gc(),
        get_projected_available_ratio(),
        get_projected_reclaim_ratio());
-    if (!segment_info.out_of_line) {
+    auto s_type = segment_info.get_type();
+    ceph_assert(s_type != segment_type_t::NULL_SEG);
+    if (s_type == segment_type_t::JOURNAL) {
       segments.journal_segment_emptied();
     }
     maybe_wake_gc_blocked_io();

diff --git a/src/test/crimson/seastore/test_seastore_journal.cc b/src/test/crimson/seastore/test_seastore_journal.cc
index 00e1944b79083c9d2075da6c55c4eedf915aa35e..9fc4421c4065ad33ace52c4a44eb7c158ea3b4d9 100644 (file)
--- a/src/test/crimson/seastore/test_seastore_journal.cc
+++ b/src/test/crimson/seastore/test_seastore_journal.cc
@@ -147,7 +147,7 @@ struct journal_test_t : seastar_test_suite_t, SegmentProvider {
          [this, &segments](auto segment_id) {
          return scanner->read_segment_header(segment_id_t{0, segment_id})
          .safe_then([&segments, segment_id](auto header) {
-           if (!header.out_of_line) {
+           if (header.get_type() == segment_type_t::JOURNAL) {
              segments.emplace_back(
                std::make_pair(
                  segment_id_t{0, segment_id},