seastore: changes due to adding blk_paddr_t

Signed-off-by: Myoungwon Oh <myoungwon.oh@samsung.com>

4 files changed, 63 insertions, 70 deletions

diff --git a/src/crimson/os/seastore/random_block_manager.h b/src/crimson/os/seastore/random_block_manager.h
index ee707478a2b..05d90205a89 100644
--- a/src/crimson/os/seastore/random_block_manager.h
+++ b/src/crimson/os/seastore/random_block_manager.h
@@ -100,5 +100,15 @@ public:
   virtual ~RandomBlockManager() {}
 };
 using RandomBlockManagerRef = std::unique_ptr<RandomBlockManager>;
+using blk_no_t = uint64_t;
+using rbm_abs_addr = uint64_t;
 
+inline rbm_abs_addr convert_paddr_to_abs_addr(paddr_t& paddr) {
+  blk_paddr_t& blk_addr = paddr.as_blk_paddr();
+  return blk_addr.get_block_off();
+}
+
+inline paddr_t convert_abs_addr_to_paddr(rbm_abs_addr addr, device_id_t d_id) {
+  return paddr_t::make_blk_paddr(d_id, addr);
+}
 }
diff --git a/src/crimson/os/seastore/random_block_manager/nvme_manager.cc b/src/crimson/os/seastore/random_block_manager/nvme_manager.cc
index 4906cad30bc..ef5eca19cc9 100644
--- a/src/crimson/os/seastore/random_block_manager/nvme_manager.cc
+++ b/src/crimson/os/seastore/random_block_manager/nvme_manager.cc
@@ -21,7 +21,7 @@ namespace {
 namespace crimson::os::seastore {
 
 NVMeManager::write_ertr::future<> NVMeManager::rbm_sync_block_bitmap(
-    rbm_bitmap_block_t &block, blk_id_t block_no)
+    rbm_bitmap_block_t &block, blk_no_t block_no)
 {
   bufferptr bptr;
   try {
@@ -67,7 +67,7 @@ NVMeManager::mkfs_ertr::future<> NVMeManager::initialize_blk_alloc_area() {
     /* initialize bitmap blocks as unused */
     auto max = max_block_by_bitmap_block();
     auto max_block = super.size / super.block_size;
-    blk_id_t end = round_up_to(max_block, max) - 1;
+    blk_no_t end = round_up_to(max_block, max) - 1;
     logger().debug(" init start {} end {} ", start, end);
     return rbm_sync_block_bitmap_by_range(
             start,
@@ -123,10 +123,8 @@ NVMeManager::mkfs_ertr::future<> NVMeManager::mkfs(mkfs_config_t config)
 {
   logger().debug("path {}", path);
   return _open_device(path).safe_then([this, &config]() {
-    blk_paddr_t addr = convert_paddr_to_blk_paddr(
-      config.start,
-      config.block_size,
-      config.blocks_per_segment);
+    rbm_abs_addr addr = convert_paddr_to_abs_addr(
+      config.start);
     return read_rbm_header(addr).safe_then([](auto super) {
       logger().debug(" already exists ");
       return mkfs_ertr::now();
@@ -134,14 +132,10 @@ NVMeManager::mkfs_ertr::future<> NVMeManager::mkfs(mkfs_config_t config)
       crimson::ct_error::enoent::handle([this, &config] (auto) {
 	super.uuid = uuid_d(); // TODO
 	super.magic = 0xFF; // TODO
-	super.start = convert_paddr_to_blk_paddr(
-	  config.start,
-	  config.block_size,
-	  config.blocks_per_segment);
-	super.end = convert_paddr_to_blk_paddr(
-	  config.end,
-	  config.block_size,
-	  config.blocks_per_segment);
+	super.start = convert_paddr_to_abs_addr(
+	  config.start);
+	super.end = convert_paddr_to_abs_addr(
+	  config.end);
 	super.block_size = config.block_size;
 	super.size = config.total_size;
 	super.free_block_count = config.total_size/config.block_size - 2;
@@ -187,7 +181,7 @@ NVMeManager::find_block_ret NVMeManager::find_free_block(Transaction &t, size_t
   auto bp = bufferptr(ceph::buffer::create_page_aligned(super.block_size));
   return seastar::do_with(uint64_t(0),
     uint64_t(super.start_alloc_area),
-    interval_set<blk_id_t>(),
+    interval_set<blk_no_t>(),
     bp,
     [&, this] (auto &allocated, auto &addr, auto &alloc_extent, auto &bp) mutable {
     return crimson::repeat(
@@ -275,10 +269,8 @@ NVMeManager::allocate_ret NVMeManager::alloc_extent(
 	if (!alloc_extent.empty()) {
 	  rbm_alloc_delta_t alloc_info;
 	  for (auto p : alloc_extent) {
-	    paddr_t paddr = convert_blk_paddr_to_paddr(
+	    paddr_t paddr = convert_abs_addr_to_paddr(
 	      p.first * super.block_size,
-	      super.block_size,
-	      super.blocks_per_segment,
 	      super.device_id);
 	    size_t len = p.second * super.block_size;
 	    alloc_info.alloc_blk_ranges.push_back(std::make_pair(paddr, len));
@@ -288,10 +280,8 @@ NVMeManager::allocate_ret NVMeManager::alloc_extent(
 	} else {
 	  return crimson::ct_error::enospc::make();
 	}
-	paddr_t paddr = convert_blk_paddr_to_paddr(
+	paddr_t paddr = convert_abs_addr_to_paddr(
 	  alloc_extent.range_start() * super.block_size,
-	  super.block_size,
-	  super.blocks_per_segment,
 	  super.device_id);
 	return allocate_ret(
 	  allocate_ertr::ready_future_marker{},
@@ -306,13 +296,11 @@ NVMeManager::allocate_ret NVMeManager::alloc_extent(
 }
 
 void NVMeManager::add_free_extent(
-    std::vector<rbm_alloc_delta_t>& v, blk_paddr_t from, size_t len)
+    std::vector<rbm_alloc_delta_t>& v, rbm_abs_addr from, size_t len)
 {
   ceph_assert(!(len % super.block_size));
-  paddr_t paddr = convert_blk_paddr_to_paddr(
+  paddr_t paddr = convert_abs_addr_to_paddr(
     from,
-    super.block_size,
-    super.blocks_per_segment,
     super.device_id);
   rbm_alloc_delta_t alloc_info;
   alloc_info.alloc_blk_ranges.push_back(std::make_pair(paddr, len));
@@ -321,7 +309,7 @@ void NVMeManager::add_free_extent(
 }
 
 NVMeManager::write_ertr::future<> NVMeManager::rbm_sync_block_bitmap_by_range(
-    blk_id_t start, blk_id_t end, bitmap_op_types_t op)
+    blk_no_t start, blk_no_t end, bitmap_op_types_t op)
 {
   auto addr = super.start_alloc_area +
 	      (start / max_block_by_bitmap_block())
@@ -455,12 +443,10 @@ NVMeManager::write_ertr::future<> NVMeManager::sync_allocation(
 	  (alloc.op == rbm_alloc_delta_t::op_types_t::SET) ?
 	  bitmap_op_types_t::ALL_SET :
 	  bitmap_op_types_t::ALL_CLEAR;
-	blk_paddr_t addr = convert_paddr_to_blk_paddr(
-	  range.first,
-	  super.block_size,
-	  super.blocks_per_segment);
-	blk_id_t start = addr / super.block_size;
-	blk_id_t end = start +
+	rbm_abs_addr addr = convert_paddr_to_abs_addr(
+	  range.first);
+	blk_no_t start = addr / super.block_size;
+	blk_no_t end = start +
 	  (round_up_to(range.second, super.block_size)) / super.block_size
 	   - 1;
 	return rbm_sync_block_bitmap_by_range(
@@ -498,10 +484,7 @@ NVMeManager::open_ertr::future<> NVMeManager::open(
 {
   logger().debug("open: path{}", path);
 
-  blk_paddr_t addr = convert_paddr_to_blk_paddr(
-    paddr,
-    super.block_size,
-    super.blocks_per_segment);
+  rbm_abs_addr addr = convert_paddr_to_abs_addr(paddr);
   return _open_device(path
       ).safe_then([this, addr]() {
       return read_rbm_header(addr).safe_then([&](auto s)
@@ -524,7 +507,7 @@ NVMeManager::open_ertr::future<> NVMeManager::open(
 }
 
 NVMeManager::write_ertr::future<> NVMeManager::write(
-  blk_paddr_t addr,
+  rbm_abs_addr addr,
   bufferptr &bptr)
 {
   ceph_assert(device);
@@ -538,7 +521,7 @@ NVMeManager::write_ertr::future<> NVMeManager::write(
 }
 
 NVMeManager::read_ertr::future<> NVMeManager::read(
-  blk_paddr_t addr,
+  rbm_abs_addr addr,
   bufferptr &bptr)
 {
   ceph_assert(device);
@@ -590,7 +573,7 @@ NVMeManager::write_ertr::future<> NVMeManager::write_rbm_header()
 }
 
 NVMeManager::read_ertr::future<rbm_metadata_header_t> NVMeManager::read_rbm_header(
-    blk_paddr_t addr)
+    rbm_abs_addr addr)
 {
   ceph_assert(device);
   bufferptr bptr =
@@ -679,7 +662,7 @@ NVMeManager::check_bitmap_blocks_ertr::future<> NVMeManager::check_bitmap_blocks
 }
 
 NVMeManager::write_ertr::future<> NVMeManager::write(
-  blk_paddr_t addr,
+  rbm_abs_addr addr,
   bufferlist &bl)
 {
   ceph_assert(device);
diff --git a/src/crimson/os/seastore/random_block_manager/nvme_manager.h b/src/crimson/os/seastore/random_block_manager/nvme_manager.h
index fa94cfea272..f0f500c72be 100644
--- a/src/crimson/os/seastore/random_block_manager/nvme_manager.h
+++ b/src/crimson/os/seastore/random_block_manager/nvme_manager.h
@@ -218,7 +218,7 @@ public:
   write_ertr::future<> complete_allocation(Transaction &t) final;
 
   open_ertr::future<> _open_device(const std::string path);
-  read_ertr::future<rbm_metadata_header_t> read_rbm_header(blk_paddr_t addr);
+  read_ertr::future<rbm_metadata_header_t> read_rbm_header(rbm_abs_addr addr);
   write_ertr::future<> write_rbm_header();
 
   size_t get_size() const final { return super.size; };
@@ -229,7 +229,7 @@ public:
     return (super.block_size - ceph::encoded_sizeof_bounded<rbm_bitmap_block_t>()) * 8;
   }
 
-  uint64_t convert_block_no_to_bitmap_block(blk_id_t block_no)
+  uint64_t convert_block_no_to_bitmap_block(blk_no_t block_no)
   {
     ceph_assert(super.block_size);
     return block_no / max_block_by_bitmap_block();
@@ -240,7 +240,7 @@ public:
    *
    * return block id using address where freebitmap is stored and offset
    */
-  blk_id_t convert_bitmap_block_no_to_block_id(uint64_t offset, blk_paddr_t addr)
+  blk_no_t convert_bitmap_block_no_to_block_id(uint64_t offset, rbm_abs_addr addr)
   {
     ceph_assert(super.block_size);
     // freebitmap begins at block 1
@@ -261,7 +261,7 @@ public:
   using find_block_ertr = crimson::errorator<
     crimson::ct_error::input_output_error,
     crimson::ct_error::enoent>;
-  using find_block_ret = find_block_ertr::future<interval_set<blk_id_t>>;
+  using find_block_ret = find_block_ertr::future<interval_set<blk_no_t>>;
   /*
    * find_free_block
    *
@@ -282,7 +282,7 @@ public:
    *
    */
   write_ertr::future<> rbm_sync_block_bitmap(
-      rbm_bitmap_block_t &block, blk_id_t block_no);
+      rbm_bitmap_block_t &block, blk_no_t block_no);
 
   using check_bitmap_blocks_ertr = crimson::errorator<
     crimson::ct_error::input_output_error,
@@ -328,11 +328,11 @@ public:
     b_block.buf.append(bitmap_blk);
   }
 
-  blk_paddr_t get_blk_paddr_by_block_no(blk_id_t id) {
+  rbm_abs_addr get_blk_paddr_by_block_no(blk_no_t id) {
     return (id * super.block_size) + super.start;
   }
 
-  int num_block_between_blk_ids(blk_id_t start, blk_id_t end) {
+  int num_block_between_blk_ids(blk_no_t start, blk_no_t end) {
     auto max = max_block_by_bitmap_block();
     auto block_start = start / max;
     auto block_end = end / max;
@@ -340,7 +340,7 @@ public:
   }
 
   write_ertr::future<> rbm_sync_block_bitmap_by_range(
-      blk_id_t start, blk_id_t end, bitmap_op_types_t op);
+      blk_no_t start, blk_no_t end, bitmap_op_types_t op);
   void add_cont_bitmap_blocks_to_buf(
       bufferlist& buf, int num_block, bitmap_op_types_t op) {
     rbm_bitmap_block_t b_block(super.block_size);
@@ -355,11 +355,11 @@ public:
     }
   }
 
-  write_ertr::future<> write(blk_paddr_t addr, bufferlist &bl);
+  write_ertr::future<> write(rbm_abs_addr addr, bufferlist &bl);
   write_ertr::future<> sync_allocation(
       std::vector<rbm_alloc_delta_t>& alloc_blocks);
   void add_free_extent(
-      std::vector<rbm_alloc_delta_t>& v, blk_paddr_t from, size_t len);
+      std::vector<rbm_alloc_delta_t>& v, rbm_abs_addr from, size_t len);
 
   uint32_t get_blocks_per_segment() const final {
     return super.blocks_per_segment;
diff --git a/src/test/crimson/seastore/test_randomblock_manager.cc b/src/test/crimson/seastore/test_randomblock_manager.cc
index 02f266454da..39c37f63297 100644
--- a/src/test/crimson/seastore/test_randomblock_manager.cc
+++ b/src/test/crimson/seastore/test_randomblock_manager.cc
@@ -55,10 +55,12 @@ struct rbm_test_t :
   seastar::future<> set_up_fut() final {
     device.reset(new nvme_device::TestMemory(DEFAULT_TEST_SIZE));
     rbm_manager.reset(new NVMeManager(device.get(), std::string()));
-    config.start = paddr_t::make_seg_paddr(0, 0, 0);
-    config.end = paddr_t::make_seg_paddr(0, 0, DEFAULT_TEST_SIZE);
+    device_id_t d_id = 1 << (std::numeric_limits<device_id_t>::digits - 1);
+    config.start = paddr_t::make_blk_paddr(d_id, 0);
+    config.end = paddr_t::make_blk_paddr(d_id, DEFAULT_TEST_SIZE);
     config.block_size = DEFAULT_BLOCK_SIZE;
     config.total_size = DEFAULT_TEST_SIZE;
+    config.device_id = d_id;
     return tm_setup();
   }
 
@@ -73,10 +75,9 @@ struct rbm_test_t :
   }
 
   auto read_rbm_header() {
-    blk_paddr_t addr = convert_paddr_to_blk_paddr(
+    rbm_abs_addr addr = convert_paddr_to_abs_addr(
       config.start,
-      config.block_size,
-      config.blocks_per_segment);
+      config.block_size);
     return rbm_manager->read_rbm_header(addr).unsafe_get0();
   }
 
@@ -102,10 +103,9 @@ struct rbm_test_t :
     if (!extent.empty()) {
       rbm_alloc_delta_t alloc_info;
       for (auto p : extent) {
-	paddr_t paddr = convert_blk_paddr_to_paddr(
+	paddr_t paddr = convert_abs_addr_to_paddr(
 	    p.first * block_size,
 	    block_size,
-	    config.blocks_per_segment,
 	    0);
 	size_t len = p.second * block_size;
 	alloc_info.alloc_blk_ranges.push_back(std::make_pair(paddr, len));
@@ -115,7 +115,7 @@ struct rbm_test_t :
     }
   }
 
-  void free_extent(rbm_transaction &t, interval_set<blk_id_t> range) {
+  void free_extent(rbm_transaction &t, interval_set<blk_no_t> range) {
     for (auto [off, len] : range) {
       logger().debug("free_extent: start {} len {}", off * DEFAULT_BLOCK_SIZE,
 		      len * DEFAULT_BLOCK_SIZE);
@@ -124,16 +124,15 @@ struct rbm_test_t :
     }
   }
 
-  interval_set<blk_id_t> get_allocated_blk_ids(rbm_transaction &t) {
+  interval_set<blk_no_t> get_allocated_blk_ids(rbm_transaction &t) {
     auto allocated_blocks = t.get_rbm_allocated_blocks();
-    interval_set<blk_id_t> alloc_ids;
+    interval_set<blk_no_t> alloc_ids;
     for (auto p : allocated_blocks) {
       for (auto b : p.alloc_blk_ranges) {
-	blk_paddr_t addr =
-	  convert_paddr_to_blk_paddr(
+	rbm_abs_addr addr =
+	  convert_paddr_to_abs_addr(
 	    b.first,
-	    block_size,
-	    config.blocks_per_segment);
+	    block_size);
 	alloc_ids.insert(addr / block_size, b.second / block_size);
       }
     }
@@ -141,10 +140,10 @@ struct rbm_test_t :
     return alloc_ids;
   }
 
-  bool check_ids_are_allocated(interval_set<blk_id_t> &ids, bool allocated = true) {
+  bool check_ids_are_allocated(interval_set<blk_no_t> &ids, bool allocated = true) {
     bool ret = true;
     for (auto r : ids) {
-      for (blk_id_t id = r.first; id < r.first + r.second; id++) {
+      for (blk_no_t id = r.first; id < r.first + r.second; id++) {
 	auto addr = rbm_manager->get_start_block_alloc_area() +
 		     (id / rbm_manager->max_block_by_bitmap_block())
 		     * DEFAULT_BLOCK_SIZE;
@@ -287,15 +286,16 @@ TEST_F(rbm_test_t, block_alloc_free_test)
 TEST_F(rbm_test_t, many_block_alloc)
 {
  run_async([this] {
-   config.start = paddr_t::make_seg_paddr(0, 0, 0);
-   config.end = paddr_t::make_seg_paddr(0, 0, DEFAULT_TEST_SIZE * 1024);
+   device_id_t d_id = 1 << (std::numeric_limits<device_id_t>::digits - 1);
+   config.start = paddr_t::make_blk_paddr(d_id, 0);
+   config.end = paddr_t::make_blk_paddr(d_id, (DEFAULT_TEST_SIZE * 1024));
    config.block_size = DEFAULT_BLOCK_SIZE;
    config.total_size = DEFAULT_TEST_SIZE * 1024;
    mkfs();
    open();
    auto max = rbm_manager->max_block_by_bitmap_block();
    rbm_manager->rbm_sync_block_bitmap_by_range(max + 10, max + 14, bitmap_op_types_t::ALL_SET).unsafe_get0();
-   interval_set<blk_id_t> alloc_ids;
+   interval_set<blk_no_t> alloc_ids;
    alloc_ids.insert(max + 12, 2);
    ASSERT_TRUE(check_ids_are_allocated(alloc_ids));
    alloc_ids.clear();
@@ -349,7 +349,7 @@ TEST_F(rbm_test_t, check_free_blocks)
    rbm_manager->check_bitmap_blocks().unsafe_get0();
    ASSERT_TRUE(rbm_manager->get_free_blocks() == DEFAULT_TEST_SIZE/DEFAULT_BLOCK_SIZE - 5);
    auto free = rbm_manager->get_free_blocks();
-   interval_set<blk_id_t> alloc_ids;
+   interval_set<blk_no_t> alloc_ids;
    auto t = create_rbm_transaction();
    alloc_extent(*t, DEFAULT_BLOCK_SIZE * 4);
    alloc_ids = get_allocated_blk_ids(*t);