crimson/os/seastore: adapt laddr_t/laddr_offset_t get_byte_distance

Signed-off-by: Zhang Song <[email protected]>

Author: zhscn

src/crimson/os/seastore/cache.h

@@ -977,10 +977,9 @@ class Cache {
     TCachedExtentRef<T> ext;
     if (original_bptr.has_value()) {
       // shallow copy the buffer from original extent
-      auto nbp = ceph::bufferptr(
-        *original_bptr,
-        remap_laddr - original_laddr,
-        remap_length);
+      auto remap_offset = remap_laddr.get_byte_distance<
+	extent_len_t>(original_laddr);
+      auto nbp = ceph::bufferptr(*original_bptr, remap_offset, remap_length);
       // ExtentPlacementManager::alloc_new_extent will make a new
       // (relative/temp) paddr, so make extent directly
       ext = CachedExtent::make_cached_extent_ref<T>(std::move(nbp));

src/crimson/os/seastore/lba_manager/btree/btree_lba_manager.cc

@@ -325,7 +325,8 @@ BtreeLBAManager::_alloc_extents(
       total_len += info.len;
     }
   } else {
-    total_len = alloc_infos.back().key + alloc_infos.back().len - hint;
+    auto end = alloc_infos.back().key + alloc_infos.back().len;
+    total_len = end.get_byte_distance<extent_len_t>(hint);
   }
 
   struct state_t {

src/crimson/os/seastore/lba_manager/btree/btree_lba_manager.h

@@ -128,7 +128,7 @@ class BtreeLBAMapping : public BtreeNodeMapping<laddr_t, paddr_t> {
     assert(intermediate_key >= intermediate_base);
     assert((intermediate_key == L_ADDR_NULL)
       == (intermediate_base == L_ADDR_NULL));
-    return intermediate_key - intermediate_base;
+    return intermediate_key.get_byte_distance<extent_len_t>(intermediate_base);
   }
 
   extent_len_t get_intermediate_length() const final {

src/crimson/os/seastore/object_data_handler.cc

@@ -268,7 +268,7 @@ overwrite_ops_t prepare_ops_list(
       ops.to_remap.push_back(extent_to_remap_t::create_remap2(
 	std::move(front.pin),
 	front.len,
-	back.addr - front.addr - front.len));
+	back.addr.get_byte_distance<extent_len_t>(front.addr) - front.len));
       ops.to_remove.pop_front();
   } else {
     // prepare to_remap, happens in one or multiple extents
@@ -289,7 +289,7 @@ overwrite_ops_t prepare_ops_list(
 	back.pin->get_key() + back.pin->get_length());
       ops.to_remap.push_back(extent_to_remap_t::create_remap1(
 	std::move(back.pin),
-	back.addr - back.pin->get_key(),
+	back.addr.get_byte_distance<extent_len_t>(back.pin->get_key()),
 	back.len));
       ops.to_remove.pop_back();
     }
@@ -342,8 +342,9 @@ overwrite_ops_t prepare_ops_list(
 	    range.insert(r.pin->get_key(), r.pin->get_length());
 	    if (range.contains(region.addr, region.len) && !r.pin->is_clone()) {
 	      to_remap.push_back(extent_to_remap_t::create_overwrite(
-		region.addr - range.begin().get_start(), region.len,
-		std::move(r.pin), *region.to_write));
+		region.addr.get_byte_distance<
+		  extent_len_t> (range.begin().get_start()),
+		region.len, std::move(r.pin), *region.to_write));
 	      return true;
 	    }
 	    return false;
@@ -649,35 +650,35 @@ struct overwrite_plan_t {
 
 public:
   extent_len_t get_left_size() const {
-    return data_begin - pin_begin;
+    return data_begin.get_byte_distance<extent_len_t>(pin_begin);
   }
 
   extent_len_t get_left_extent_size() const {
-    return aligned_data_begin - pin_begin;
+    return aligned_data_begin.get_byte_distance<extent_len_t>(pin_begin);
   }
 
   extent_len_t get_left_alignment_size() const {
-    return data_begin - aligned_data_begin;
+    return data_begin.get_byte_distance<extent_len_t>(aligned_data_begin);
   }
 
   extent_len_t get_right_size() const {
-    return pin_end - data_end;
+    return pin_end.get_byte_distance<extent_len_t>(data_end);
   }
 
   extent_len_t get_right_extent_size() const {
-    return pin_end - aligned_data_end;
+    return pin_end.get_byte_distance<extent_len_t>(aligned_data_end);
   }
 
   extent_len_t get_right_alignment_size() const {
-    return aligned_data_end - data_end;
+    return aligned_data_end.get_byte_distance<extent_len_t>(data_end);
   }
 
   extent_len_t get_aligned_data_size() const {
-    return aligned_data_end - aligned_data_begin;
+    return aligned_data_end.get_byte_distance<extent_len_t>(aligned_data_begin);
   }
 
   extent_len_t get_pins_size() const {
-    return pin_end - pin_begin;
+    return pin_end.get_byte_distance<extent_len_t>(pin_begin);
   }
 
   friend std::ostream& operator<<(
@@ -942,9 +943,9 @@ operate_ret operate_right(context_t ctx, LBAMappingRef &pin, const overwrite_pla
         std::nullopt);
     } else {
       auto append_offset =
-	overwrite_plan.data_end
-	- right_pin_begin
-	+ pin->get_intermediate_offset();
+	overwrite_plan.data_end.get_byte_distance<
+	  extent_len_t>(right_pin_begin)
+	  + pin->get_intermediate_offset();
       return ctx.tm.read_pin<ObjectDataBlock>(
 	ctx.t, pin->duplicate()
       ).si_then([append_offset, append_len](auto right_extent) {
@@ -974,9 +975,9 @@ operate_ret operate_right(context_t ctx, LBAMappingRef &pin, const overwrite_pla
         std::nullopt);
     } else {
       auto append_offset =
-	overwrite_plan.data_end
-	- right_pin_begin
-	+ pin->get_intermediate_offset();
+	overwrite_plan.data_end.get_byte_distance<
+	  extent_len_t>(right_pin_begin)
+	  + pin->get_intermediate_offset();
       return ctx.tm.read_pin<ObjectDataBlock>(
 	ctx.t, pin->duplicate()
       ).si_then([append_offset, append_len,
@@ -1102,8 +1103,8 @@ ObjectDataHandler::clear_ret ObjectDataHandler::trim_data_reservation(
 	ceph_assert(pin.get_key() >= object_data.get_reserved_data_base());
 	ceph_assert(
 	  pin.get_key() <= object_data.get_reserved_data_base() + size);
-	auto pin_offset = pin.get_key() -
-	  object_data.get_reserved_data_base();
+	auto pin_offset = pin.get_key().template get_byte_distance<extent_len_t>(
+	  object_data.get_reserved_data_base());
 	if ((pin.get_key() == (object_data.get_reserved_data_base() + size)) ||
 	  (pin.get_val().is_zero())) {
 	  /* First pin is exactly at the boundary or is a zero pin.  Either way,
@@ -1517,10 +1518,12 @@ ObjectDataHandler::read_ret ObjectDataHandler::read(
               DEBUGT("got {}~{} from zero-pin {}~{}",
                 ctx.t,
                 l_current,
-                l_current_end - l_current,
+                l_current_end.get_byte_distance<loffset_t>(l_current),
                 pin_key,
                 pin_len);
-              ret.append_zero(l_current_end - l_current);
+              ret.append_zero(
+		l_current_end.get_byte_distance<
+		  extent_len_t>(l_current));
               l_current = l_current_end;
               return seastar::now();
             }
@@ -1537,7 +1540,7 @@ ObjectDataHandler::read_ret ObjectDataHandler::read(
               DEBUGT("reading {}~{} from indirect-pin {}~{}, direct-pin {}~{}(off={})",
                 ctx.t,
                 l_current,
-                l_current_end - l_current,
+		l_current_end.get_byte_distance<extent_len_t>(l_current),
                 pin_key,
                 pin_len,
                 e_key,
@@ -1549,14 +1552,16 @@ ObjectDataHandler::read_ret ObjectDataHandler::read(
               DEBUGT("reading {}~{} from pin {}~{}",
                 ctx.t,
                 l_current,
-                l_current_end - l_current,
+		l_current_end.get_byte_distance<
+		   extent_len_t>(l_current),
                 pin_key,
                 pin_len);
               e_key = pin_key;
               e_len = pin_len;
               e_off = 0;
             }
-            extent_len_t e_current_off = e_off + l_current - pin_key;
+            extent_len_t e_current_off = (l_current + e_off)
+		.template get_byte_distance<extent_len_t>(pin_key);
             return ctx.tm.read_pin<ObjectDataBlock>(
               ctx.t,
               std::move(pin)
@@ -1572,7 +1577,7 @@ ObjectDataHandler::read_ret ObjectDataHandler::read(
                 bufferptr(
                   extent->get_bptr(),
                   e_current_off,
-                  l_current_end - l_current));
+                  l_current_end.get_byte_distance<extent_len_t>(l_current)));
               l_current = l_current_end;
               return seastar::now();
             }).handle_error_interruptible(
@@ -1637,8 +1642,9 @@ ObjectDataHandler::fiemap_ret ObjectDataHandler::fiemap(
 	    assert(ret_right > ret_left);
 	    ret.emplace(
 	      std::make_pair(
-		ret_left - object_data.get_reserved_data_base(),
-		ret_right - ret_left
+		ret_left.get_byte_distance<uint64_t>(
+		  object_data.get_reserved_data_base()),
+		ret_right.get_byte_distance<uint64_t>(ret_left)
 	      ));
 	  }
 	}
@@ -1716,7 +1722,8 @@ ObjectDataHandler::clone_ret ObjectDataHandler::clone_extents(
 	return trans_intr::do_for_each(
 	  pins,
 	  [&last_pos, &object_data, ctx, data_base](auto &pin) {
-	  auto offset = pin->get_key() - data_base;
+	  auto offset = pin->get_key().template get_byte_distance<
+	    extent_len_t>(data_base);
 	  ceph_assert(offset == last_pos);
 	  auto fut = TransactionManager::alloc_extent_iertr
 	    ::make_ready_future<LBAMappingRef>();

src/crimson/tools/store_nbd/tm_driver.cc

@@ -117,7 +117,7 @@ seastar::future<bufferlist> TMDriver::read(
         for (auto &i: ext_list) {
           if (cur != i.first) {
             assert(cur < i.first);
-            blret.append_zero(i.first - cur);
+            blret.append_zero(i.first.template get_byte_distance<size_t>(cur));
             cur = i.first;
           }
           blret.append(i.second->get_bptr());

src/test/crimson/seastore/test_object_data_handler.cc

@@ -632,7 +632,7 @@ TEST_P(object_data_handler_test_t, remap_left) {
     auto base = pins.front()->get_key();
     int i = 0;
     for (auto &pin : pins) {
-      EXPECT_EQ(pin->get_key() - base, res[i]);
+      EXPECT_EQ(pin->get_key().get_byte_distance<size_t>(base), res[i]);
       i++;
     }
     read(0, 128<<10);
@@ -666,7 +666,7 @@ TEST_P(object_data_handler_test_t, remap_right) {
     auto base = pins.front()->get_key();
     int i = 0;
     for (auto &pin : pins) {
-      EXPECT_EQ(pin->get_key() - base, res[i]);
+      EXPECT_EQ(pin->get_key().get_byte_distance<size_t>(base), res[i]);
       i++;
     }
     read(0, 128<<10);
@@ -699,7 +699,7 @@ TEST_P(object_data_handler_test_t, remap_right_left) {
     auto base = pins.front()->get_key();
     int i = 0;
     for (auto &pin : pins) {
-      EXPECT_EQ(pin->get_key() - base, res[i]);
+      EXPECT_EQ(pin->get_key().get_byte_distance<size_t>(base), res[i]);
       i++;
     }
     enable_max_extent_size();
@@ -730,7 +730,7 @@ TEST_P(object_data_handler_test_t, multiple_remap) {
     auto base = pins.front()->get_key();
     int i = 0;
     for (auto &pin : pins) {
-      EXPECT_EQ(pin->get_key() - base, res[i]);
+      EXPECT_EQ(pin->get_key().get_byte_distance<size_t>(base), res[i]);
       i++;
     }
     read(0, 128<<10);

src/test/crimson/seastore/test_transaction_manager.cc

@@ -254,7 +254,7 @@ struct transaction_manager_test_t :
 	  EXPECT_EQ(addr, last);
 	  break;
 	}
-	EXPECT_FALSE((iter->first - last).to_byte_offset() > len);
+	EXPECT_FALSE(iter->first.get_byte_distance<extent_len_t>(last) > len);
 	last = (iter->first + iter->second.desc.len).checked_to_laddr();
 	++iter;
       }
@@ -1575,7 +1575,8 @@ struct transaction_manager_test_t :
 	      if (off == 0 || off >= 255) {
 		continue;
 	      }
-              auto new_off = laddr_t(off << 10) - last_pin->get_key();
+              auto new_off = laddr_t::from_byte_offset(off << 10)
+		  .get_byte_distance<extent_len_t>(last_pin->get_key());
               auto new_len = last_pin->get_length() - new_off;
               //always remap right extent at new split_point
 	      auto pin = remap_pin(t, std::move(last_pin), new_off, new_len);
@@ -1674,7 +1675,8 @@ struct transaction_manager_test_t :
                 continue;
               }
               empty_transaction = false;
-              auto new_off = laddr_t(start_off << 10) - last_rpin->get_key();
+              auto new_off = laddr_t::from_byte_offset(start_off << 10)
+		  .get_byte_distance<extent_len_t>(last_rpin->get_key());
               auto new_len = (end_off - start_off) << 10;
               bufferlist bl;
               bl.append(ceph::bufferptr(ceph::buffer::create(new_len, 0)));