crimson/os/seastore: construct laddr_t explicitly

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

Author: zhscn

src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_manager/dummy.h

@@ -150,7 +150,8 @@ class DummyNodeExtentManager final: public NodeExtentManager {
       Transaction& t, extent_len_t len) {
     assert(len % ALIGNMENT == 0);
     auto r = ceph::buffer::create_aligned(len, ALIGNMENT);
-    auto addr = laddr_t(reinterpret_cast<laddr_t::Unsigned>(r->get_data()));
+    auto addr = laddr_t::from_byte_offset(
+      reinterpret_cast<laddr_t::Unsigned>(r->get_data()));
     auto bp = ceph::bufferptr(std::move(r));
     auto extent = Ref<DummyNodeExtent>(new DummyNodeExtent(std::move(bp)));
     extent->set_laddr(addr);

src/crimson/os/seastore/onode_manager/staged-fltree/stages/key_layout.h

@@ -46,9 +46,9 @@ static laddr_t get_lba_hint(shard_t shard, pool_t pool, crush_hash_t crush) {
   // FIXME: It is possible that PGs from different pools share the same prefix
   // if the mask 0xFF is not long enough, result in unexpected transaction
   // conflicts.
-  return laddr_t((uint64_t)(shard & 0xFF)<<56 |
-                 (uint64_t)(pool  & 0xFF)<<48 |
-                 (uint64_t)(crush       )<<16);
+  return laddr_t::from_raw_uint((uint64_t)(shard & 0xFF)<<56 |
+                                (uint64_t)(pool  & 0xFF)<<48 |
+                                (uint64_t)(crush       )<<16);
 }
 
 struct node_offset_packed_t {

src/crimson/tools/store_nbd/tm_driver.cc

@@ -27,20 +27,20 @@ seastar::future<> TMDriver::write(
         "write",
         [this, offset, &ptr](auto& t)
       {
-        return tm->remove(t, laddr_t(offset)
+        return tm->remove(t, laddr_t::from_byte_offset(offset)
         ).discard_result().handle_error_interruptible(
           crimson::ct_error::enoent::handle([](auto) { return seastar::now(); }),
           crimson::ct_error::pass_further_all{}
         ).si_then([this, offset, &t, &ptr] {
           logger().debug("dec_ref complete");
-          return tm->alloc_data_extents<TestBlock>(t, laddr_t(offset), ptr.length());
+          return tm->alloc_data_extents<TestBlock>(t, laddr_t::from_byte_offset(offset), ptr.length());
         }).si_then([this, offset, &t, &ptr](auto extents) mutable {
 	  boost::ignore_unused(offset);  // avoid clang warning;
 	  auto off = offset;
 	  auto left = ptr.length();
 	  size_t written = 0;
 	  for (auto &ext : extents) {
-	    assert(ext->get_laddr() == laddr_t(off));
+	    assert(ext->get_laddr() == laddr_t::from_byte_offset(off));
 	    assert(ext->get_bptr().length() <= left);
 	    ptr.copy_out(written, ext->get_length(), ext->get_bptr().c_str());
 	    off += ext->get_length();
@@ -111,9 +111,9 @@ seastar::future<bufferlist> TMDriver::read(
       "read",
       [=, &blret, this](auto& t)
     {
-      return read_extents(t, laddr_t(offset), size
+      return read_extents(t, laddr_t::from_byte_offset(offset), size
       ).si_then([=, &blret](auto ext_list) {
-        laddr_t cur(offset);
+        auto cur = laddr_t::from_byte_offset(offset);
         for (auto &i: ext_list) {
           if (cur != i.first) {
             assert(cur < i.first);

src/test/crimson/seastore/onode_tree/test_fltree_onode_manager.cc

@@ -32,16 +32,16 @@ struct onode_item_t {
   void initialize(Transaction& t, Onode& value) const {
     auto &ftvalue = static_cast<FLTreeOnode&>(value);
     ftvalue.update_onode_size(t, size);
-    auto oroot = omap_root_t(laddr_t(id), cnt_modify,
+    auto oroot = omap_root_t(laddr_t::from_raw_uint(id), cnt_modify,
       value.get_metadata_hint(block_size));
     ftvalue.update_omap_root(t, oroot);
     validate(value);
   }
 
   void validate(Onode& value) const {
     auto& layout = value.get_layout();
-    ceph_assert(laddr_t(layout.size) == laddr_t{size});
-    ceph_assert(layout.omap_root.get(value.get_metadata_hint(block_size)).addr == laddr_t(id));
+    ceph_assert(uint64_t(layout.size) == uint64_t{size});
+    ceph_assert(layout.omap_root.get(value.get_metadata_hint(block_size)).addr == laddr_t::from_raw_uint(id));
     ceph_assert(layout.omap_root.get(value.get_metadata_hint(block_size)).depth == cnt_modify);
   }
 

src/test/crimson/seastore/onode_tree/test_staged_fltree.cc

@@ -1048,7 +1048,7 @@ class DummyChildPool {
     static Ref<DummyChild> create_new(
         const std::set<ghobject_t>& keys, bool is_level_tail, DummyChildPool& pool) {
       static uint64_t seed = 0;
-      return create(keys, is_level_tail, laddr_t(seed++), pool);
+      return create(keys, is_level_tail, laddr_t::from_raw_uint(seed++), pool);
     }
 
     static eagain_ifuture<Ref<DummyChild>> create_initial(

src/test/crimson/seastore/test_btree_lba_manager.cc

@@ -378,14 +378,14 @@ TEST_F(lba_btree_test, basic)
   run_async([this] {
     constexpr unsigned total = 16<<10;
     for (unsigned i = 0; i < total; i += 16) {
-      insert(laddr_t(i), 8);
+      insert(laddr_t::from_raw_uint(i), 8);
     }
 
     for (unsigned i = 0; i < total; i += 16) {
-      check_lower_bound(laddr_t(i));
-      check_lower_bound(laddr_t(i + 4));
-      check_lower_bound(laddr_t(i + 8));
-      check_lower_bound(laddr_t(i + 12));
+      check_lower_bound(laddr_t::from_raw_uint(i));
+      check_lower_bound(laddr_t::from_raw_uint(i + 4));
+      check_lower_bound(laddr_t::from_raw_uint(i + 8));
+      check_lower_bound(laddr_t::from_raw_uint(i + 12));
     }
   });
 }
@@ -681,7 +681,7 @@ struct btree_lba_manager_test : btree_test_base {
 TEST_F(btree_lba_manager_test, basic)
 {
   run_async([this] {
-    laddr_t laddr = laddr_t(0x12345678 * block_size);
+    laddr_t laddr = laddr_t::from_byte_offset(0x12345678 * block_size);
     {
       // write initial mapping
       auto t = create_transaction();
@@ -831,23 +831,23 @@ TEST_F(btree_lba_manager_test, split_merge_multi)
       }
     };
     iterate([&](auto &t, auto idx) {
-      alloc_mappings(t, laddr_t(idx * block_size), block_size);
+      alloc_mappings(t, laddr_t::from_byte_offset(idx * block_size), block_size);
     });
     check_mappings();
     iterate([&](auto &t, auto idx) {
       if ((idx % 32) > 0) {
-	decref_mapping(t, laddr_t(idx * block_size));
+	decref_mapping(t, laddr_t::from_byte_offset(idx * block_size));
       }
     });
     check_mappings();
     iterate([&](auto &t, auto idx) {
       if ((idx % 32) > 0) {
-	alloc_mappings(t, laddr_t(idx * block_size), block_size);
+	alloc_mappings(t, laddr_t::from_byte_offset(idx * block_size), block_size);
       }
     });
     check_mappings();
     iterate([&](auto &t, auto idx) {
-      decref_mapping(t, laddr_t(idx * block_size));
+      decref_mapping(t, laddr_t::from_byte_offset(idx * block_size));
     });
     check_mappings();
   });

src/test/crimson/seastore/test_object_data_handler.cc

@@ -218,14 +218,14 @@ struct object_data_handler_test_t:
     objaddr_t offset,
     extent_len_t length) {
     auto ret = with_trans_intr(t, [&](auto &t) {
-      return tm->get_pins(t, laddr_t(offset), length);
+      return tm->get_pins(t, laddr_t::from_byte_offset(offset), length);
     }).unsafe_get();
     return ret;
   }
   std::list<LBAMappingRef> get_mappings(objaddr_t offset, extent_len_t length) {
     auto t = create_mutate_transaction();
     auto ret = with_trans_intr(*t, [&](auto &t) {
-      return tm->get_pins(t, laddr_t(offset), length);
+      return tm->get_pins(t, laddr_t::from_byte_offset(offset), length);
     }).unsafe_get();
     return ret;
   }
@@ -798,7 +798,7 @@ TEST_P(object_data_handler_test_t, overwrite_then_read_within_transaction) {
       auto pins = get_mappings(*t, base, len);
       assert(pins.size() == 1);
       auto pin1 = remap_pin(*t, std::move(pins.front()), 4096, 8192);
-      auto ext = get_extent(*t, laddr_t(base + 4096), 4096 * 2);
+      auto ext = get_extent(*t, laddr_t::from_byte_offset(base + 4096), 4096 * 2);
       ASSERT_TRUE(ext->is_exist_clean());
       write(*t, base + 4096, 4096, 'y');
       ASSERT_TRUE(ext->is_exist_mutation_pending());