crimson/os/seastore/seastore_types: prefer paddr_t::is_absolute_*()

Signed-off-by: Yingxin Cheng <yingxin.cheng@intel.com>

diff --git a/src/crimson/os/seastore/async_cleaner.cc b/src/crimson/os/seastore/async_cleaner.cc
index 60e2635c3cff9043785c901de004c2b2b2b5b5fc..d3880a7ce1e9cf7a9dd8f7c206eac7f643a470dd 100644 (file)
--- a/src/crimson/os/seastore/async_cleaner.cc
+++ b/src/crimson/os/seastore/async_cleaner.cc
@@ -1521,7 +1521,7 @@ bool SegmentCleaner::check_usage()
         extent_types_t type,
         laddr_t laddr)
     {
-      if (paddr.get_addr_type() == paddr_types_t::SEGMENT) {
+      if (paddr.is_absolute_segmented()) {
         if (is_backref_node(type)) {
          assert(laddr == L_ADDR_NULL);
          assert(backref_key.is_absolute_segmented()
@@ -1557,7 +1557,7 @@ void SegmentCleaner::mark_space_used(
   assert(background_callback->get_state() >= state_t::SCAN_SPACE);
   assert(len);
   // TODO: drop
-  if (addr.get_addr_type() != paddr_types_t::SEGMENT) {
+  if (!addr.is_absolute_segmented()) {
     return;
   }
 
@@ -1588,7 +1588,7 @@ void SegmentCleaner::mark_space_free(
   assert(background_callback->get_state() >= state_t::SCAN_SPACE);
   assert(len);
   // TODO: drop
-  if (addr.get_addr_type() != paddr_types_t::SEGMENT) {
+  if (!addr.is_absolute_segmented()) {
     return;
   }
 
@@ -1722,7 +1722,7 @@ void RBMCleaner::mark_space_used(
   extent_len_t len)
 {
   LOG_PREFIX(RBMCleaner::mark_space_used);
-  assert(addr.get_addr_type() == paddr_types_t::RANDOM_BLOCK);
+  assert(addr.is_absolute_random_block());
   auto rbms = rb_group->get_rb_managers();
   for (auto rbm : rbms) {
     if (addr.get_device_id() == rbm->get_device_id()) {
@@ -1741,7 +1741,7 @@ void RBMCleaner::mark_space_free(
   extent_len_t len)
 {
   LOG_PREFIX(RBMCleaner::mark_space_free);
-  assert(addr.get_addr_type() == paddr_types_t::RANDOM_BLOCK);
+  assert(addr.is_absolute_random_block());
   auto rbms = rb_group->get_rb_managers();
   for (auto rbm : rbms) {
     if (addr.get_device_id() == rbm->get_device_id()) {

diff --git a/src/crimson/os/seastore/backref/btree_backref_manager.cc b/src/crimson/os/seastore/backref/btree_backref_manager.cc
index c021ad92b3f9f94f49ea127352f96ddb2dc0fd23..bf912b3464724be7732824f2581709ea5dae9e3a 100644 (file)
--- a/src/crimson/os/seastore/backref/btree_backref_manager.cc
+++ b/src/crimson/os/seastore/backref/btree_backref_manager.cc
@@ -161,7 +161,7 @@ BtreeBackrefManager::new_mapping(
 {
   ceph_assert(
     is_aligned(
-      key.get_addr_type() == paddr_types_t::SEGMENT ?
+      key.is_absolute_segmented() ?
        key.as_seg_paddr().get_segment_off() :
        key.as_blk_paddr().get_device_off(),
       cache.get_block_size()));

diff --git a/src/crimson/os/seastore/cache.cc b/src/crimson/os/seastore/cache.cc
index b9f13e3525d03b01b3468ec439f293ceefa48cdb..12681a44912a8ebfdc9126457e1834255f268531 100644 (file)
--- a/src/crimson/os/seastore/cache.cc
+++ b/src/crimson/os/seastore/cache.cc
@@ -1269,8 +1269,7 @@ record_t Cache::prepare_record(
        assert(can_inplace_rewrite(i->prior_instance->get_type()));
        assert(i->prior_instance->dirty_from_or_retired_at == JOURNAL_SEQ_MIN);
        assert(i->prior_instance->state == CachedExtent::extent_state_t::CLEAN);
-       assert(i->prior_instance->get_paddr().get_addr_type() ==
-         paddr_types_t::RANDOM_BLOCK);
+       assert(i->prior_instance->get_paddr().is_absolute_random_block());
        i->version = 1;
       }
 
@@ -1310,7 +1309,7 @@ record_t Cache::prepare_record(
       auto stype = segment_type_t::NULL_SEG;
 
       // FIXME: This is specific to the segmented implementation
-      if (i->get_paddr().get_addr_type() == paddr_types_t::SEGMENT) {
+      if (i->get_paddr().is_absolute_segmented()) {
         auto sid = i->get_paddr().as_seg_paddr().get_segment_id();
         auto sinfo = get_segment_info(sid);
         if (sinfo) {
@@ -2063,7 +2062,7 @@ Cache::replay_delta(
       DEBUG("replay extent delta at {} {} ... -- {}, prv_extent={}",
             journal_seq, record_base, delta, *extent);
 
-      if (delta.paddr.get_addr_type() == paddr_types_t::SEGMENT ||
+      if (delta.paddr.is_absolute_segmented() ||
          !can_inplace_rewrite(delta.type)) {
        ceph_assert_always(extent->last_committed_crc == delta.prev_crc);
        assert(extent->version == delta.pversion);
@@ -2071,7 +2070,7 @@ Cache::replay_delta(
        extent->set_modify_time(modify_time);
        ceph_assert_always(extent->last_committed_crc == delta.final_crc);
       } else {
-       assert(delta.paddr.get_addr_type() == paddr_types_t::RANDOM_BLOCK);
+       assert(delta.paddr.is_absolute_random_block());
        // see prepare_record(), inplace rewrite might cause version mismatch
        extent->apply_delta_and_adjust_crc(record_base, delta.bl);
        extent->set_modify_time(modify_time);

diff --git a/src/crimson/os/seastore/record_scanner.h b/src/crimson/os/seastore/record_scanner.h
index 2cb17af8df9df796049c20d020ba393c3c687a96..3420f6b7770c18ae024eace62a15fd0a0c2fccdf 100644 (file)
--- a/src/crimson/os/seastore/record_scanner.h
+++ b/src/crimson/os/seastore/record_scanner.h
@@ -30,11 +30,11 @@ public:
   ); ///< @return used budget
 
   device_off_t get_segment_off(paddr_t addr) const {
-    if (addr.get_addr_type() == paddr_types_t::SEGMENT) {
+    if (addr.is_absolute_segmented()) {
       auto& seg_addr = addr.as_seg_paddr();
       return seg_addr.get_segment_off();
     }
-    assert(addr.get_addr_type() == paddr_types_t::RANDOM_BLOCK);
+    assert(addr.is_absolute_random_block());
     auto& blk_addr = addr.as_blk_paddr();
     return blk_addr.get_device_off();
   }

diff --git a/src/crimson/os/seastore/seastore_types.cc b/src/crimson/os/seastore/seastore_types.cc
index 24fb135cfa5851e5f2834a20da51b023304dc0e1..a22d77aa0b1b34994d983ffd83bde49eee9a7db2 100644 (file)
--- a/src/crimson/os/seastore/seastore_types.cc
+++ b/src/crimson/os/seastore/seastore_types.cc
@@ -127,12 +127,12 @@ std::ostream &operator<<(std::ostream &out, const paddr_t &rhs)
     out << device_id_printer_t{id}
         << ",0x"
         << std::hex << s.get_device_off() << std::dec;
-  } else if (rhs.get_addr_type() == paddr_types_t::SEGMENT) {
+  } else if (rhs.is_absolute_segmented()) {
     auto &s = rhs.as_seg_paddr();
     out << s.get_segment_id()
         << ",0x"
         << std::hex << s.get_segment_off() << std::dec;
-  } else if (rhs.get_addr_type() == paddr_types_t::RANDOM_BLOCK) {
+  } else if (rhs.is_absolute_random_block()) {
     auto &s = rhs.as_blk_paddr();
     out << device_id_printer_t{s.get_device_id()}
         << ",0x"

diff --git a/src/crimson/os/seastore/seastore_types.h b/src/crimson/os/seastore/seastore_types.h
index 5871c2f51ea0c112a6ab67e5fc606d44c7b24b43..f797321e1fb56c9244c4a9ab9a4746f5083f2532 100644 (file)
--- a/src/crimson/os/seastore/seastore_types.h
+++ b/src/crimson/os/seastore/seastore_types.h
@@ -565,10 +565,6 @@ public:
     return static_cast<device_id_t>(internal_paddr >> DEVICE_OFF_BITS);
   }
 
-  paddr_types_t get_addr_type() const {
-    return device_id_to_paddr_type(get_device_id());
-  }
-
   paddr_t add_offset(device_off_t o) const;
 
   paddr_t add_relative(paddr_t o) const;
@@ -701,7 +697,7 @@ private:
               encode_device_off(offset)) {
     assert(offset >= DEVICE_OFF_MIN);
     assert(offset <= DEVICE_OFF_MAX);
-    assert(get_addr_type() != paddr_types_t::SEGMENT);
+    assert(!is_absolute_segmented());
   }
 
   paddr_t(internal_paddr_t val);
@@ -711,6 +707,10 @@ private:
     : internal_paddr((static_cast<internal_paddr_t>(d_id) << DEVICE_OFF_BITS) |
                      static_cast<u_device_off_t>(offset)) {}
 
+  paddr_types_t get_addr_type() const {
+    return device_id_to_paddr_type(get_device_id());
+  }
+
   friend struct paddr_le_t;
   friend struct pladdr_le_t;
 
@@ -827,22 +827,22 @@ inline paddr_t make_delayed_temp_paddr(device_off_t off) {
 }
 
 inline const seg_paddr_t& paddr_t::as_seg_paddr() const {
-  assert(get_addr_type() == paddr_types_t::SEGMENT);
+  assert(is_absolute_segmented());
   return *static_cast<const seg_paddr_t*>(this);
 }
 
 inline seg_paddr_t& paddr_t::as_seg_paddr() {
-  assert(get_addr_type() == paddr_types_t::SEGMENT);
+  assert(is_absolute_segmented());
   return *static_cast<seg_paddr_t*>(this);
 }
 
 inline const blk_paddr_t& paddr_t::as_blk_paddr() const {
-  assert(get_addr_type() == paddr_types_t::RANDOM_BLOCK);
+  assert(is_absolute_random_block());
   return *static_cast<const blk_paddr_t*>(this);
 }
 
 inline blk_paddr_t& paddr_t::as_blk_paddr() {
-  assert(get_addr_type() == paddr_types_t::RANDOM_BLOCK);
+  assert(is_absolute_random_block());
   return *static_cast<blk_paddr_t*>(this);
 }
 
@@ -1009,18 +1009,15 @@ private:
     }
     using ret_t = std::pair<device_off_t, segment_id_t>;
     auto to_pair = [](const paddr_t &addr) -> ret_t {
-      if (addr.get_addr_type() == paddr_types_t::SEGMENT) {
+      if (addr.is_absolute_segmented()) {
        auto &seg_addr = addr.as_seg_paddr();
        return ret_t(seg_addr.get_segment_off(), seg_addr.get_segment_id());
-      } else if (addr.get_addr_type() == paddr_types_t::RANDOM_BLOCK) {
+      } else if (addr.is_absolute_random_block()) {
        auto &blk_addr = addr.as_blk_paddr();
        return ret_t(blk_addr.get_device_off(), MAX_SEG_ID);
-      } else if (addr.get_addr_type() == paddr_types_t::RESERVED) {
+      } else {
         auto &res_addr = addr.as_res_paddr();
         return ret_t(res_addr.get_device_off(), MAX_SEG_ID);
-      } else {
-       assert(0 == "impossible");
-       return ret_t(0, MAX_SEG_ID);
       }
     };
     auto left = to_pair(offset);

diff --git a/src/crimson/os/seastore/transaction_manager.cc b/src/crimson/os/seastore/transaction_manager.cc
index ac11813f31381809d4994a4d0b368235f457ce76..e7bf690c5e3d08af84792986bde1482507aee623 100644 (file)
--- a/src/crimson/os/seastore/transaction_manager.cc
+++ b/src/crimson/os/seastore/transaction_manager.cc
@@ -691,7 +691,7 @@ TransactionManager::get_extents_if_live(
 
   // This only works with segments to check if alive,
   // as parallel transactions may split the extent at the same time.
-  ceph_assert(paddr.get_addr_type() == paddr_types_t::SEGMENT);
+  ceph_assert(paddr.is_absolute_segmented());
 
   return cache->get_extent_if_cached(t, paddr, len, type
   ).si_then([this, FNAME, type, paddr, laddr, len, &t](auto extent)
@@ -727,7 +727,7 @@ TransactionManager::get_extents_if_live(
           {
             DEBUGT("got pin, try read in parallel ... -- {}", t, *pin);
             auto pin_paddr = pin->get_val();
-            if (pin_paddr.get_addr_type() != paddr_types_t::SEGMENT) {
+            if (!pin_paddr.is_absolute_segmented()) {
               return seastar::now();
             }
             auto &pin_seg_paddr = pin_paddr.as_seg_paddr();