crimson/os/journal: use SegmentManager methods for block size, etc

Otherwise, initing those values needs to be done after the SegmentManager
instance is mounted.  This is simpler for now.

Signed-off-by: Samuel Just <sjust@redhat.com>

diff --git a/src/crimson/os/seastore/journal.cc b/src/crimson/os/seastore/journal.cc
index 26db668087045e8011bf5c5b8277972c46933130..4482193981f77040c0177aebc600907a879d30d5 100644 (file)
--- a/src/crimson/os/seastore/journal.cc
+++ b/src/crimson/os/seastore/journal.cc
@@ -49,12 +49,7 @@ segment_nonce_t generate_nonce(
 }
 
 Journal::Journal(SegmentManager &segment_manager)
-  : block_size(segment_manager.get_block_size()),
-    max_record_length(
-      segment_manager.get_segment_size() -
-      p2align(ceph::encoded_sizeof_bounded<segment_header_t>(),
-             size_t(block_size))),
-    segment_manager(segment_manager) {}
+  : segment_manager(segment_manager) {}
 
 
 Journal::initialize_segment_ertr::future<segment_seq_t>
@@ -130,6 +125,7 @@ ceph::bufferlist Journal::encode_record(
   for (const auto &i: record.deltas) {
     encode(i, bl);
   }
+  auto block_size = segment_manager.get_block_size();
   if (bl.length() % block_size != 0) {
     bl.append_zero(
       block_size - (bl.length() % block_size));
@@ -194,7 +190,7 @@ Journal::write_record_ret Journal::write_record(
   ceph::bufferlist to_write = encode_record(
     rsize, std::move(record));
   auto target = written_to;
-  assert((to_write.length() % block_size) == 0);
+  assert((to_write.length() % segment_manager.get_block_size()) == 0);
   written_to += to_write.length();
   logger().debug(
     "write_record, mdlength {}, dlength {}, target {}",
@@ -249,7 +245,7 @@ Journal::record_size_t Journal::get_encoded_record_length(
   for (const auto &i: record.extents) {
     data += i.bl.length();
   }
-  metadata = p2roundup(metadata, block_size);
+  metadata = p2roundup(metadata, (extent_len_t)segment_manager.get_block_size());
   return record_size_t{metadata, data};
 }
 
@@ -293,7 +289,9 @@ Journal::roll_journal_segment()
 Journal::read_segment_header_ret
 Journal::read_segment_header(segment_id_t segment)
 {
-  return segment_manager.read(paddr_t{segment, 0}, block_size
+  return segment_manager.read(
+    paddr_t{segment, 0},
+    segment_manager.get_block_size()
   ).handle_error(
     read_segment_header_ertr::pass_further{},
     crimson::ct_error::assert_all{
@@ -309,7 +307,7 @@ Journal::read_segment_header(segment_id_t segment)
     logger().debug(
       "Journal::read_segment_header: segment {} block crc {}",
       segment,
-      bl.begin().crc32c(block_size, 0));
+      bl.begin().crc32c(segment_manager.get_block_size(), 0));
 
     auto bp = bl.cbegin();
     try {
@@ -340,7 +338,7 @@ Journal::open_for_write_ret Journal::open_for_write()
        seq,
        paddr_t{
          current_journal_segment->get_segment_id(),
-         static_cast<segment_off_t>(block_size)}
+           static_cast<segment_off_t>(segment_manager.get_block_size())}
       });
   });
 }
@@ -435,7 +433,9 @@ Journal::find_replay_segments_fut Journal::find_replay_segments()
              assert(0 == "invalid");
            }
          } else {
-           replay_from = paddr_t{from->first, (segment_off_t)block_size};
+           replay_from = paddr_t{
+             from->first,
+             (segment_off_t)segment_manager.get_block_size()};
          }
          auto ret = replay_segments_t(segments.end() - from);
          std::transform(
@@ -443,7 +443,9 @@ Journal::find_replay_segments_fut Journal::find_replay_segments()
            [this](const auto &p) {
              auto ret = journal_seq_t{
                p.second.journal_segment_seq,
-               paddr_t{p.first, (segment_off_t)block_size}};
+               paddr_t{
+                 p.first,
+                 (segment_off_t)segment_manager.get_block_size()}};
              logger().debug(
                "Journal::find_replay_segments: replaying from  {}",
                ret);
@@ -461,6 +463,7 @@ Journal::read_validate_record_metadata_ret Journal::read_validate_record_metadat
   paddr_t start,
   segment_nonce_t nonce)
 {
+  auto block_size = segment_manager.get_block_size();
   if (start.offset + block_size > (int64_t)segment_manager.get_segment_size()) {
     return read_validate_record_metadata_ret(
       read_validate_record_metadata_ertr::ready_future_marker{},
@@ -471,6 +474,7 @@ Journal::read_validate_record_metadata_ret Journal::read_validate_record_metadat
     [=](bufferptr bptr) mutable
     -> read_validate_record_metadata_ret {
       logger().debug("read_validate_record_metadata: reading {}", start);
+      auto block_size = segment_manager.get_block_size();
       bufferlist bl;
       bl.append(bptr);
       auto bp = bl.cbegin();
@@ -487,7 +491,7 @@ Journal::read_validate_record_metadata_ret Journal::read_validate_record_metadat
          read_validate_record_metadata_ertr::ready_future_marker{},
          std::nullopt);
       }
-      if (header.mdlength > block_size) {
+      if (header.mdlength > (extent_len_t)block_size) {
        if (start.offset + header.mdlength >
            (int64_t)segment_manager.get_segment_size()) {
          return crimson::ct_error::input_output_error::make();
@@ -697,7 +701,7 @@ Journal::scan_valid_records_ret Journal::scan_valid_records(
     found_record_handler_t &handler)
 {
   if (cursor.offset.offset == 0) {
-    cursor.offset.offset = block_size;
+    cursor.offset.offset = segment_manager.get_block_size();
   }
   auto retref = std::make_unique<size_t>(0);
   auto budget_used = *retref;

diff --git a/src/crimson/os/seastore/journal.h b/src/crimson/os/seastore/journal.h
index 3ab0b10a39d5b2370ac8fcb73132a4ff9a728ef5..d2cfe1383f5905bb9dc1360754f2e97bde1188eb 100644 (file)
--- a/src/crimson/os/seastore/journal.h
+++ b/src/crimson/os/seastore/journal.h
@@ -180,12 +180,12 @@ public:
     assert(write_pipeline);
     auto rsize = get_encoded_record_length(record);
     auto total = rsize.mdlength + rsize.dlength;
-    if (total > max_record_length) {
+    if (total > max_record_length()) {
       auto &logger = crimson::get_logger(ceph_subsys_filestore);
       logger.error(
        "Journal::submit_record: record size {} exceeds max {}",
        total,
-       max_record_length
+       max_record_length()
       );
       return crimson::ct_error::erange::make();
     }
@@ -244,9 +244,6 @@ public:
   }
 
 private:
-  const extent_len_t block_size;
-  const extent_len_t max_record_length;
-
   JournalSegmentProvider *segment_provider = nullptr;
   SegmentManager &segment_manager;
 
@@ -415,6 +412,7 @@ private:
     delta_handler_t &delta_handler   ///< [in] processes deltas in order
   );
 
+  extent_len_t max_record_length() const;
 };
 using JournalRef = std::unique_ptr<Journal>;
 
@@ -422,3 +420,13 @@ using JournalRef = std::unique_ptr<Journal>;
 WRITE_CLASS_DENC_BOUNDED(crimson::os::seastore::segment_header_t)
 WRITE_CLASS_DENC_BOUNDED(crimson::os::seastore::record_header_t)
 WRITE_CLASS_DENC_BOUNDED(crimson::os::seastore::extent_info_t)
+
+namespace crimson::os::seastore {
+
+inline extent_len_t Journal::max_record_length() const {
+  return segment_manager.get_segment_size() -
+    p2align(ceph::encoded_sizeof_bounded<segment_header_t>(),
+           size_t(segment_manager.get_block_size()));
+}
+
+}