crimson/os/seastore: laddr_offset_t can align to mulitple UNIT_SIZE now

Signed-off-by: Xuehan Xu <xuxuehan@qianxin.com>

diff --git a/src/crimson/os/seastore/object_data_handler.cc b/src/crimson/os/seastore/object_data_handler.cc
index 78ce2329bc75a9a0ce058f86b6d3336423e7b94f..abdbfd327f9708473fdb37227644b2fb011523a8 100644 (file)
--- a/src/crimson/os/seastore/object_data_handler.cc
+++ b/src/crimson/os/seastore/object_data_handler.cc
@@ -1005,19 +1005,21 @@ ObjectDataHandler::write_ret ObjectDataHandler::overwrite(
   assert(!bl.has_value() || bl->length() == len);
   auto unaligned_begin = data_base + offset;
   auto unaligned_end = data_base + offset + len;
-  assert(first_mapping.get_key() <= unaligned_begin.get_aligned_laddr());
+  assert(first_mapping.get_key() <= unaligned_begin.get_aligned_laddr(
+    ctx.tm.get_block_size()));
   DEBUGT(
     "data_base={}, offset=0x{:x}, len=0x{:x}, "
     "aligned_begin={}, aligned_end={}",
     ctx.t, data_base, offset, len,
-    unaligned_begin.get_aligned_laddr(),
-    unaligned_end.get_roundup_laddr());
+    unaligned_begin.get_aligned_laddr(ctx.tm.get_block_size()),
+    unaligned_end.get_roundup_laddr(ctx.tm.get_block_size()));
   return seastar::do_with(
     data_t{std::nullopt, std::move(bl), std::nullopt},
     overwrite_range_t{
       len,
       unaligned_begin,
-      unaligned_end},
+      unaligned_end,
+      ctx.tm.get_block_size()},
     [first_mapping=std::move(first_mapping),
     this, ctx](auto &data, auto &overwrite_range) {
     if (overwrite_range.is_range_in_mapping(first_mapping)) {
@@ -1168,9 +1170,10 @@ ObjectDataHandler::read_ret ObjectDataHandler::read(
       laddr_offset_t l_start =
         object_data.get_reserved_data_base() + obj_offset;
       laddr_offset_t l_end = l_start + len;
-      laddr_t aligned_start = l_start.get_aligned_laddr();
+      laddr_t aligned_start = l_start.get_aligned_laddr(
+       ctx.tm.get_block_size());
       loffset_t aligned_length =
-         l_end.get_roundup_laddr().get_byte_distance<
+         l_end.get_roundup_laddr(ctx.tm.get_block_size()).get_byte_distance<
            loffset_t>(aligned_start);
       return ctx.tm.get_pins(
         ctx.t,
@@ -1192,7 +1195,8 @@ ObjectDataHandler::read_ret ObjectDataHandler::read(
             extent_len_t read_start;
             extent_len_t read_start_aligned;
             if (l_current == l_start) { // first pin may skip head
-              ceph_assert(l_current.get_aligned_laddr() >= pin_start);
+              ceph_assert(l_current.get_aligned_laddr(
+               ctx.tm.get_block_size()) >= pin_start);
               read_start = l_current.template
                 get_byte_distance<extent_len_t>(pin_start);
               read_start_aligned = p2align(read_start, ctx.tm.get_block_size());
@@ -1225,7 +1229,8 @@ ObjectDataHandler::read_ret ObjectDataHandler::read(
             }
 
             // non-zero pin
-            laddr_t l_current_end_aligned = l_current_end.get_roundup_laddr();
+            laddr_t l_current_end_aligned =
+             l_current_end.get_roundup_laddr(ctx.tm.get_block_size());
             extent_len_t read_len_aligned =
               l_current_end_aligned.get_byte_distance<extent_len_t>(pin_start);
             read_len_aligned -= read_start_aligned;
@@ -1300,9 +1305,10 @@ ObjectDataHandler::fiemap_ret ObjectDataHandler::fiemap(
       laddr_offset_t l_start =
         object_data.get_reserved_data_base() + obj_offset;
       laddr_offset_t l_end = l_start + len;
-      laddr_t aligned_start = l_start.get_aligned_laddr();
+      laddr_t aligned_start = l_start.get_aligned_laddr(
+       ctx.tm.get_block_size());
       loffset_t aligned_length =
-         l_end.get_roundup_laddr().get_byte_distance<
+         l_end.get_roundup_laddr(ctx.tm.get_block_size()).get_byte_distance<
            loffset_t>(aligned_start);
       return ctx.tm.get_pins(
         ctx.t,

diff --git a/src/crimson/os/seastore/object_data_handler.h b/src/crimson/os/seastore/object_data_handler.h
index 5656d3d19e0a16f446fc6c612424dcbad07f4bdf..8750c066e9649595db08d669620b9888586364f4 100644 (file)
--- a/src/crimson/os/seastore/object_data_handler.h
+++ b/src/crimson/os/seastore/object_data_handler.h
@@ -89,12 +89,13 @@ struct overwrite_range_t {
   overwrite_range_t(
     objaddr_t unaligned_len,
     laddr_offset_t unaligned_begin,
-    laddr_offset_t unaligned_end)
+    laddr_offset_t unaligned_end,
+    extent_len_t block_size)
     : unaligned_len(unaligned_len),
       unaligned_begin(unaligned_begin),
       unaligned_end(unaligned_end),
-      aligned_begin(unaligned_begin.get_aligned_laddr()),
-      aligned_end(unaligned_end.get_roundup_laddr()),
+      aligned_begin(unaligned_begin.get_aligned_laddr(block_size)),
+      aligned_end(unaligned_end.get_roundup_laddr(block_size)),
       aligned_len(
        aligned_end.template get_byte_distance<
          extent_len_t>(aligned_begin))

diff --git a/src/crimson/os/seastore/seastore_types.cc b/src/crimson/os/seastore/seastore_types.cc
index 4f1a593d841c0447a9ff9686c1e954eda7e63968..deccef846ba95433dd74b2b0a9feef775af663e8 100644 (file)
--- a/src/crimson/os/seastore/seastore_types.cc
+++ b/src/crimson/os/seastore/seastore_types.cc
@@ -99,7 +99,7 @@ std::ostream &operator<<(std::ostream &out, const laddr_t &laddr) {
 }
 
 std::ostream &operator<<(std::ostream &out, const laddr_offset_t &laddr_offset) {
-  return out << laddr_offset.get_aligned_laddr()
+  return out << laddr_offset.get_laddr()
             << "+0x" << std::hex << laddr_offset.get_offset() << std::dec;
 }
 

diff --git a/src/crimson/os/seastore/seastore_types.h b/src/crimson/os/seastore/seastore_types.h
index f3ad75865653830b5574edd6750290cda1de20ee..308b1d6226140b524a1db15f736e65a04d193f94 100644 (file)
--- a/src/crimson/os/seastore/seastore_types.h
+++ b/src/crimson/os/seastore/seastore_types.h
@@ -1130,15 +1130,22 @@ public:
       assert(offset < laddr_t::UNIT_SIZE);
     }
 
-    laddr_t get_roundup_laddr() const {
+    laddr_t get_roundup_laddr(size_t alignment) const {
+      ceph_assert(alignment % laddr_t::UNIT_SIZE == 0);
       if (offset == 0) {
-       return laddr_t(base);
+       return laddr_t(p2roundup(base, alignment >> laddr_t::UNIT_SHIFT));
       } else {
        assert(offset < laddr_t::UNIT_SIZE);
-       return laddr_t(base + 1);
+       return laddr_t(p2roundup(base + 1, alignment >> laddr_t::UNIT_SHIFT));
       }
     }
-    laddr_t get_aligned_laddr() const { return laddr_t(base); }
+    laddr_t get_aligned_laddr(size_t alignment) const {
+      ceph_assert(alignment % laddr_t::UNIT_SIZE == 0);
+      return laddr_t(p2align(base, alignment >> laddr_t::UNIT_SHIFT));
+    }
+    laddr_t get_laddr() const {
+      return laddr_t{base};
+    }
     extent_len_t get_offset() const {
       assert(offset < laddr_t::UNIT_SIZE);
       return offset;
@@ -1190,8 +1197,7 @@ public:
     friend laddr_offset_t operator+(const laddr_offset_t &laddr_offset,
                                    const loffset_t &offset) {
       // laddr_offset_t could access (laddr_t + loffset_t) overload.
-      return laddr_offset.get_aligned_laddr()
-         + (laddr_offset.get_offset() + offset);
+      return laddr_offset.get_laddr() + (laddr_offset.get_offset() + offset);
     }
     friend laddr_offset_t operator+(const loffset_t &offset,
                                    const laddr_offset_t &loffset) {
@@ -1202,11 +1208,11 @@ public:
                                    const loffset_t &offset) {
       if (laddr_offset.get_offset() >= offset) {
        return laddr_offset_t(
-         laddr_offset.get_aligned_laddr(),
+         laddr_offset.get_laddr(),
          laddr_offset.get_offset() - offset);
       } else {
        // laddr_offset_t could access (laddr_t - loffset_t) overload.
-       return laddr_offset.get_aligned_laddr()
+       return laddr_offset.get_laddr()
            - (offset - laddr_offset.get_offset());
       }
     }
@@ -1244,12 +1250,12 @@ public:
   friend bool operator==(const laddr_t&, const laddr_t&) = default;
   friend bool operator==(const laddr_t &laddr,
                         const laddr_offset_t &laddr_offset) {
-    return laddr == laddr_offset.get_aligned_laddr()
+    return laddr == laddr_offset.get_laddr()
        && 0 == laddr_offset.get_offset();
   }
   friend bool operator==(const laddr_offset_t &laddr_offset,
                         const laddr_t &laddr) {
-    return laddr_offset.get_aligned_laddr() == laddr
+    return laddr_offset.get_laddr() == laddr
        && laddr_offset.get_offset() == 0;
   }
   friend auto operator<=>(const laddr_t&, const laddr_t&) = default;