From: Samuel Just <sjust@redhat.com>
Date: Fri, 11 Jun 2021 00:21:26 +0000 (-0700)
Subject: crimson/os/seastore/lba_manager/btree: convert to use interruptible_future
X-Git-Tag: v17.1.0~1567^2~4
X-Git-Url: http://git.apps.os.sepia.ceph.com/?a=commitdiff_plain;h=98fd17bbe446584599f52c3395cce8d935dd4d06;p=ceph.git

crimson/os/seastore/lba_manager/btree: convert to use interruptible_future

Signed-off-by: Samuel Just <sjust@redhat.com>
---

diff --git a/src/crimson/os/seastore/lba_manager.h b/src/crimson/os/seastore/lba_manager.h
index d1e5b5eb15b26..5dbf0a0f8e2ec 100644
--- a/src/crimson/os/seastore/lba_manager.h
+++ b/src/crimson/os/seastore/lba_manager.h
@@ -23,12 +23,24 @@
 
 namespace crimson::os::seastore {
 
+#define LBA_INT_FORWARD(METHOD)						\
+  template <typename... Args>						\
+  auto METHOD(Transaction &t, Args&&... args) {				\
+    return with_trans_intr(						\
+      t,								\
+    [this](auto&&... args) {						\
+      return this->_##METHOD(args...);					\
+    },									\
+    std::forward<Args>(args)...);					\
+  }
+
 /**
  * Abstract interface for managing the logical to physical mapping
  */
 class LBAManager {
 public:
-  using base_ertr = Cache::get_extent_ertr;
+  using base_ertr = Cache::base_ertr;
+  using base_iertr = Cache::base_iertr;
 
   using mkfs_ertr = crimson::errorator<
     crimson::ct_error::input_output_error>;
@@ -43,8 +55,9 @@ public:
    * Future will not resolve until all pins have resolved (set_paddr called)
    */
   using get_mappings_ertr = base_ertr;
-  using get_mappings_ret = get_mappings_ertr::future<lba_pin_list_t>;
-  virtual get_mappings_ret get_mappings(
+  using get_mappings_iertr = trans_iertr<base_ertr>;
+  using get_mappings_ret = get_mappings_iertr::future<lba_pin_list_t>;
+  virtual get_mappings_ret _get_mappings(
     Transaction &t,
     laddr_t offset, extent_len_t length) = 0;
 
@@ -53,9 +66,10 @@ public:
    *
    * Future will not resolve until all pins have resolved (set_paddr called)
    */
-  virtual get_mappings_ret get_mappings(
+  virtual get_mappings_ret _get_mappings(
     Transaction &t,
     laddr_list_t &&extent_lisk) = 0;
+  LBA_INT_FORWARD(get_mappings)
 
   /**
    * Fetches the mapping for laddr_t
@@ -64,22 +78,27 @@ public:
    */
   using get_mapping_ertr = base_ertr::extend<
     crimson::ct_error::enoent>;
-  using get_mapping_ret = get_mapping_ertr::future<LBAPinRef>;
-  virtual get_mapping_ret get_mapping(
+  using get_mapping_iertr = base_iertr::extend<
+    crimson::ct_error::enoent>;
+  using get_mapping_ret = get_mapping_iertr::future<LBAPinRef>;
+  virtual get_mapping_ret _get_mapping(
     Transaction &t,
     laddr_t offset) = 0;
+  LBA_INT_FORWARD(get_mapping)
 
   /**
    * Finds unmapped laddr extent of len len
    */
   using find_hole_ertr = base_ertr;
-  using find_hole_ret = find_hole_ertr::future<
+  using find_hole_iertr = base_iertr;
+  using find_hole_ret = find_hole_iertr::future<
     std::pair<laddr_t, extent_len_t>
     >;
-  virtual find_hole_ret find_hole(
+  virtual find_hole_ret _find_hole(
     Transaction &t,
     laddr_t hint,
     extent_len_t) = 0;
+  LBA_INT_FORWARD(find_hole)
 
   /**
    * Allocates a new mapping referenced by LBARef
@@ -89,24 +108,27 @@ public:
    * is called on the LBAPin.
    */
   using alloc_extent_ertr = base_ertr;
-  using alloc_extent_ret = alloc_extent_ertr::future<LBAPinRef>;
-  virtual alloc_extent_ret alloc_extent(
+  using alloc_extent_iertr = base_iertr;
+  using alloc_extent_ret = alloc_extent_iertr::future<LBAPinRef>;
+  virtual alloc_extent_ret _alloc_extent(
     Transaction &t,
     laddr_t hint,
     extent_len_t len,
     paddr_t addr) = 0;
+  LBA_INT_FORWARD(alloc_extent)
 
   /**
    * Creates a new absolute mapping.
    *
    * off~len must be unreferenced
    */
-  using set_extent_ertr = base_ertr::extend<
+  using set_extent_iertr = base_iertr::extend<
     crimson::ct_error::invarg>;
-  using set_extent_ret = set_extent_ertr::future<LBAPinRef>;
-  virtual set_extent_ret set_extent(
+  using set_extent_ret = set_extent_iertr::future<LBAPinRef>;
+  virtual set_extent_ret _set_extent(
     Transaction &t,
     laddr_t off, extent_len_t len, paddr_t addr) = 0;
+  LBA_INT_FORWARD(set_extent)
 
 
   struct ref_update_result_t {
@@ -116,25 +138,29 @@ public:
   };
   using ref_ertr = base_ertr::extend<
     crimson::ct_error::enoent>;
-  using ref_ret = ref_ertr::future<ref_update_result_t>;
+  using ref_iertr = base_iertr::extend<
+    crimson::ct_error::enoent>;
+  using ref_ret = ref_iertr::future<ref_update_result_t>;
 
   /**
    * Decrements ref count on extent
    *
    * @return returns resulting refcount
    */
-  virtual ref_ret decref_extent(
+  virtual ref_ret _decref_extent(
     Transaction &t,
     laddr_t addr) = 0;
+  LBA_INT_FORWARD(decref_extent)
 
   /**
    * Increments ref count on extent
    *
    * @return returns resulting refcount
    */
-  virtual ref_ret incref_extent(
+  virtual ref_ret _incref_extent(
     Transaction &t,
     laddr_t addr) = 0;
+  LBA_INT_FORWARD(incref_extent)
 
   virtual void complete_transaction(
     Transaction &t) = 0;
@@ -145,47 +171,51 @@ public:
    * LogicalCachedExtent's and may also read in any dependent
    * structures, etc.
    */
-  using init_cached_extent_ertr = base_ertr;
-  using init_cached_extent_ret = init_cached_extent_ertr::future<>;
-  virtual init_cached_extent_ret init_cached_extent(
+  using init_cached_extent_iertr = base_iertr;
+  using init_cached_extent_ret = init_cached_extent_iertr::future<>;
+  virtual init_cached_extent_ret _init_cached_extent(
     Transaction &t,
     CachedExtentRef e) = 0;
+  LBA_INT_FORWARD(init_cached_extent)
 
   /**
    * Calls f for each mapping in [begin, end)
    */
-  using scan_mappings_ertr = base_ertr;
-  using scan_mappings_ret = scan_mappings_ertr::future<>;
+  using scan_mappings_iertr = base_iertr;
+  using scan_mappings_ret = scan_mappings_iertr::future<>;
   using scan_mappings_func_t = std::function<
     void(laddr_t, paddr_t, extent_len_t)>;
-  virtual scan_mappings_ret scan_mappings(
+  virtual scan_mappings_ret _scan_mappings(
     Transaction &t,
     laddr_t begin,
     laddr_t end,
     scan_mappings_func_t &&f) = 0;
+  LBA_INT_FORWARD(scan_mappings)
 
   /**
    * Calls f for each mapped space usage in [begin, end)
    */
-  using scan_mapped_space_ertr = base_ertr::extend_ertr<
+  using scan_mapped_space_iertr = base_iertr::extend_ertr<
     SegmentManager::read_ertr>;
-  using scan_mapped_space_ret = scan_mapped_space_ertr::future<>;
+  using scan_mapped_space_ret = scan_mapped_space_iertr::future<>;
   using scan_mapped_space_func_t = std::function<
     void(paddr_t, extent_len_t)>;
-  virtual scan_mapped_space_ret scan_mapped_space(
+  virtual scan_mapped_space_ret _scan_mapped_space(
     Transaction &t,
     scan_mapped_space_func_t &&f) = 0;
+  LBA_INT_FORWARD(scan_mapped_space)
 
   /**
    * rewrite_extent
    *
    * rewrite extent into passed transaction
    */
-  using rewrite_extent_ertr = base_ertr;
-  using rewrite_extent_ret = rewrite_extent_ertr::future<>;
-  virtual rewrite_extent_ret rewrite_extent(
+  using rewrite_extent_iertr = base_iertr;
+  using rewrite_extent_ret = rewrite_extent_iertr::future<>;
+  virtual rewrite_extent_ret _rewrite_extent(
     Transaction &t,
     CachedExtentRef extent) = 0;
+  LBA_INT_FORWARD(rewrite_extent)
 
   /**
    * get_physical_extent_if_live
@@ -196,15 +226,16 @@ public:
    *
    * Returns a null CachedExtentRef if extent is not live.
    */
-  using get_physical_extent_if_live_ertr = base_ertr;
+  using get_physical_extent_if_live_iertr = base_iertr;
   using get_physical_extent_if_live_ret =
-    get_physical_extent_if_live_ertr::future<CachedExtentRef>;
-  virtual get_physical_extent_if_live_ret get_physical_extent_if_live(
+    get_physical_extent_if_live_iertr::future<CachedExtentRef>;
+  virtual get_physical_extent_if_live_ret _get_physical_extent_if_live(
     Transaction &t,
     extent_types_t type,
     paddr_t addr,
     laddr_t laddr,
     segment_off_t len) = 0;
+  LBA_INT_FORWARD(get_physical_extent_if_live)
 
   virtual void add_pin(LBAPin &pin) = 0;
 
diff --git a/src/crimson/os/seastore/lba_manager/btree/btree_lba_manager.cc b/src/crimson/os/seastore/lba_manager/btree/btree_lba_manager.cc
index 164885e0f5b2b..328044a9108d0 100644
--- a/src/crimson/os/seastore/lba_manager/btree/btree_lba_manager.cc
+++ b/src/crimson/os/seastore/lba_manager/btree/btree_lba_manager.cc
@@ -23,29 +23,33 @@ BtreeLBAManager::mkfs_ret BtreeLBAManager::mkfs(
   Transaction &t)
 {
   logger().debug("BtreeLBAManager::mkfs");
-  return cache.get_root(t).safe_then([this, &t](auto croot) {
-    auto root_leaf = cache.alloc_new_extent<LBALeafNode>(
-      t,
-      LBA_BLOCK_SIZE);
-    root_leaf->set_size(0);
-    lba_node_meta_t meta{0, L_ADDR_MAX, 1};
-    root_leaf->set_meta(meta);
-    root_leaf->pin.set_range(meta);
-    croot->get_root().lba_root =
-      lba_root_t{root_leaf->get_paddr(), 1u};
-    return mkfs_ertr::now();
-  }).handle_error(
-    mkfs_ertr::pass_further{},
-    crimson::ct_error::assert_all{
-      "Invalid error in BtreeLBAManager::mkfs"
-    }
-  );
+  return with_trans_intr(
+    t,
+    [this](auto &t) {
+      return cache.get_root(t).si_then([this, &t](auto croot) {
+	auto root_leaf = cache.alloc_new_extent<LBALeafNode>(
+	  t,
+	  LBA_BLOCK_SIZE);
+	root_leaf->set_size(0);
+	lba_node_meta_t meta{0, L_ADDR_MAX, 1};
+	root_leaf->set_meta(meta);
+	root_leaf->pin.set_range(meta);
+	croot->get_root().lba_root =
+	  lba_root_t{root_leaf->get_paddr(), 1u};
+	return mkfs_ertr::now();
+      });
+    }).handle_error(
+      mkfs_ertr::pass_further{},
+      crimson::ct_error::assert_all{
+	"Invalid error in BtreeLBAManager::mkfs"
+      }
+    );
 }
 
 BtreeLBAManager::get_root_ret
 BtreeLBAManager::get_root(Transaction &t)
 {
-  return cache.get_root(t).safe_then([this, &t](auto croot) {
+  return cache.get_root(t).si_then([this, &t](auto croot) {
     logger().debug(
       "BtreeLBAManager::get_root: reading root at {} depth {}",
       paddr_t{croot->get_root().lba_root.get_location()},
@@ -60,28 +64,26 @@ BtreeLBAManager::get_root(Transaction &t)
 }
 
 BtreeLBAManager::get_mappings_ret
-BtreeLBAManager::get_mappings(
+BtreeLBAManager::_get_mappings(
   Transaction &t,
   laddr_t offset, extent_len_t length)
 {
   logger().debug("BtreeLBAManager::get_mappings: {}, {}", offset, length);
   return get_root(
-    t).safe_then([this, &t, offset, length](auto extent) {
+    t).si_then([this, &t, offset, length](auto extent) {
       return extent->lookup_range(
 	get_context(t),
 	offset, length
-      ).safe_then([](auto &&e) {
+      ).si_then([](auto &&e) {
         logger().debug("BtreeLBAManager::get_mappings: got mappings {}", e);
-        return get_mappings_ret(
-          get_mappings_ertr::ready_future_marker{},
-          std::move(e));
+        return std::move(e);
       });
   });
 }
 
 
 BtreeLBAManager::get_mappings_ret
-BtreeLBAManager::get_mappings(
+BtreeLBAManager::_get_mappings(
   Transaction &t,
   laddr_list_t &&list)
 {
@@ -89,58 +91,55 @@ BtreeLBAManager::get_mappings(
   auto l = std::make_unique<laddr_list_t>(std::move(list));
   auto retptr = std::make_unique<lba_pin_list_t>();
   auto &ret = *retptr;
-  return crimson::do_for_each(
+  return trans_intr::do_for_each(
     l->begin(),
     l->end(),
     [this, &t, &ret](const auto &p) {
-      return get_mappings(t, p.first, p.second).safe_then(
+      return _get_mappings(t, p.first, p.second).si_then(
 	[&ret](auto res) {
 	  ret.splice(ret.end(), res, res.begin(), res.end());
+	  return get_mappings_iertr::now();
 	});
-    }).safe_then([l=std::move(l), retptr=std::move(retptr)]() mutable {
+    }).si_then([l=std::move(l), retptr=std::move(retptr)]() mutable {
       return std::move(*retptr);
     });
 }
 
 BtreeLBAManager::get_mapping_ret
-BtreeLBAManager::get_mapping(
+BtreeLBAManager::_get_mapping(
   Transaction &t,
   laddr_t offset)
 {
   logger().debug("BtreeLBAManager::get_mapping: {}", offset);
   return get_root(t
-  ).safe_then([this, &t, offset] (auto extent) {
+  ).si_then([this, &t, offset] (auto extent) {
     return extent->lookup_pin(get_context(t), offset);
-  }).safe_then([] (auto &&e) {
+  }).si_then([] (auto &&e) {
     logger().debug("BtreeLBAManager::get_mapping: got mapping {}", *e);
-    return get_mapping_ret(
-      get_mapping_ertr::ready_future_marker{},
-      std::move(e));
+    return std::move(e);
   });
 }
 
 BtreeLBAManager::find_hole_ret
-BtreeLBAManager::find_hole(
+BtreeLBAManager::_find_hole(
   Transaction &t,
   laddr_t hint,
   extent_len_t len)
 {
   return get_root(t
-  ).safe_then([this, hint, len, &t](auto extent) {
+  ).si_then([this, hint, len, &t](auto extent) {
     return extent->find_hole(
       get_context(t),
       hint,
       L_ADDR_MAX,
       len);
-  }).safe_then([len](auto addr) {
-    return seastar::make_ready_future<std::pair<laddr_t, extent_len_t>>(
-      addr, len);
+  }).si_then([len](auto addr) {
+    return std::make_pair(addr, len);
   });
-
 }
 
 BtreeLBAManager::alloc_extent_ret
-BtreeLBAManager::alloc_extent(
+BtreeLBAManager::_alloc_extent(
   Transaction &t,
   laddr_t hint,
   extent_len_t len,
@@ -148,7 +147,7 @@ BtreeLBAManager::alloc_extent(
 {
   // TODO: we can certainly combine the lookup and the insert.
   return get_root(
-    t).safe_then([this, &t, hint, len](auto extent) {
+    t).si_then([this, &t, hint, len](auto extent) {
       logger().debug(
 	"BtreeLBAManager::alloc_extent: beginning search at {}",
 	*extent);
@@ -156,10 +155,10 @@ BtreeLBAManager::alloc_extent(
 	get_context(t),
 	hint,
 	L_ADDR_MAX,
-	len).safe_then([extent](auto ret) {
+	len).si_then([extent](auto ret) {
 	  return std::make_pair(ret, extent);
 	});
-    }).safe_then([this, &t, len, addr](auto allocation_pair) {
+    }).si_then([this, &t, len, addr](auto allocation_pair) {
       auto &[laddr, extent] = allocation_pair;
       ceph_assert(laddr != L_ADDR_MAX);
       return insert_mapping(
@@ -167,34 +166,32 @@ BtreeLBAManager::alloc_extent(
 	extent,
 	laddr,
 	{ len, addr, 1, 0 }
-      ).safe_then([laddr=laddr, addr, len](auto pin) {
+      ).si_then([laddr=laddr, addr, len](auto pin) {
 	logger().debug(
 	  "BtreeLBAManager::alloc_extent: alloc {}~{} for {}",
 	  laddr,
 	  len,
 	  addr);
-	return alloc_extent_ret(
-	  alloc_extent_ertr::ready_future_marker{},
-	  LBAPinRef(pin.release()));
+	return LBAPinRef(pin.release());
       });
     });
 }
 
 BtreeLBAManager::set_extent_ret
-BtreeLBAManager::set_extent(
+BtreeLBAManager::_set_extent(
   Transaction &t,
   laddr_t off, extent_len_t len, paddr_t addr)
 {
   return get_root(
-    t).safe_then([this, &t, off, len, addr](auto root) {
+    t).si_then([this, &t, off, len, addr](auto root) {
       return insert_mapping(
 	t,
 	root,
 	off,
 	{ len, addr, 1, 0 });
-    }).safe_then([](auto ret) {
+    }).si_then([](auto ret) {
       return set_extent_ret(
-	set_extent_ertr::ready_future_marker{},
+	interruptible::ready_future_marker{},
 	LBAPinRef(ret.release()));
     });
 }
@@ -277,12 +274,12 @@ void BtreeLBAManager::complete_transaction(
   }
 }
 
-BtreeLBAManager::init_cached_extent_ret BtreeLBAManager::init_cached_extent(
+BtreeLBAManager::init_cached_extent_ret BtreeLBAManager::_init_cached_extent(
   Transaction &t,
   CachedExtentRef e)
 {
   logger().debug("{}: {}", __func__, *e);
-  return get_root(t).safe_then(
+  return get_root(t).si_then(
     [this, &t, e=std::move(e)](LBANodeRef root) mutable {
       if (is_lba_node(*e)) {
 	auto lban = e->cast<LBANode>();
@@ -291,7 +288,7 @@ BtreeLBAManager::init_cached_extent_ret BtreeLBAManager::init_cached_extent(
 	  op_context_t{cache, pin_set, t},
 	  lban->get_node_meta().begin,
 	  lban->get_node_meta().depth
-	).safe_then([this, e=std::move(e)](LBANodeRef c) {
+	).si_then([this, e=std::move(e)](LBANodeRef c) {
 	  if (c->get_paddr() == e->get_paddr()) {
 	    assert(&*c == &*e);
 	    logger().debug("init_cached_extent: {} initialized", *e);
@@ -300,14 +297,14 @@ BtreeLBAManager::init_cached_extent_ret BtreeLBAManager::init_cached_extent(
 	    logger().debug("init_cached_extent: {} obsolete", *e);
 	    cache.drop_from_cache(e);
 	  }
-	  return init_cached_extent_ertr::now();
+	  return init_cached_extent_iertr::now();
 	});
       } else if (e->is_logical()) {
 	auto logn = e->cast<LogicalCachedExtent>();
 	return root->lookup_range(
 	  op_context_t{cache, pin_set, t},
 	  logn->get_laddr(),
-	  logn->get_length()).safe_then(
+	  logn->get_length()).si_then(
 	    [this, logn=std::move(logn)](auto pins) {
 	      if (pins.size() == 1) {
 		auto pin = std::move(pins.front());
@@ -327,16 +324,16 @@ BtreeLBAManager::init_cached_extent_ret BtreeLBAManager::init_cached_extent(
 		logger().debug("init_cached_extent: {} obsolete", *logn);
 		cache.drop_from_cache(logn);
 	      }
-	      return init_cached_extent_ertr::now();
+	      return init_cached_extent_iertr::now();
 	    });
       } else {
 	logger().debug("init_cached_extent: {} skipped", *e);
-	return init_cached_extent_ertr::now();
+	return init_cached_extent_iertr::now();
       }
     });
 }
 
-BtreeLBAManager::scan_mappings_ret BtreeLBAManager::scan_mappings(
+BtreeLBAManager::scan_mappings_ret BtreeLBAManager::_scan_mappings(
   Transaction &t,
   laddr_t begin,
   laddr_t end,
@@ -346,7 +343,7 @@ BtreeLBAManager::scan_mappings_ret BtreeLBAManager::scan_mappings(
     std::move(f),
     LBANodeRef(),
     [=, &t](auto &f, auto &lbarootref) {
-      return get_root(t).safe_then(
+      return get_root(t).si_then(
 	[=, &t, &f](LBANodeRef lbaroot) mutable {
 	  lbarootref = lbaroot;
 	  return lbaroot->scan_mappings(
@@ -358,7 +355,7 @@ BtreeLBAManager::scan_mappings_ret BtreeLBAManager::scan_mappings(
     });
 }
 
-BtreeLBAManager::scan_mapped_space_ret BtreeLBAManager::scan_mapped_space(
+BtreeLBAManager::scan_mapped_space_ret BtreeLBAManager::_scan_mapped_space(
     Transaction &t,
     scan_mapped_space_func_t &&f)
 {
@@ -366,7 +363,7 @@ BtreeLBAManager::scan_mapped_space_ret BtreeLBAManager::scan_mapped_space(
     std::move(f),
     LBANodeRef(),
     [=, &t](auto &f, auto &lbarootref) {
-      return get_root(t).safe_then(
+      return get_root(t).si_then(
 	[=, &t, &f](LBANodeRef lbaroot) mutable {
 	  lbarootref = lbaroot;
 	  return lbaroot->scan_mapped_space(
@@ -376,7 +373,7 @@ BtreeLBAManager::scan_mapped_space_ret BtreeLBAManager::scan_mapped_space(
     });
 }
 
-BtreeLBAManager::rewrite_extent_ret BtreeLBAManager::rewrite_extent(
+BtreeLBAManager::rewrite_extent_ret BtreeLBAManager::_rewrite_extent(
   Transaction &t,
   CachedExtentRef extent)
 {
@@ -422,13 +419,9 @@ BtreeLBAManager::rewrite_extent_ret BtreeLBAManager::rewrite_extent(
 	ceph_assert(in.paddr == prev_addr);
 	ret.paddr = addr;
 	return ret;
-      }).safe_then(
+      }).si_then(
 	[nlextent](auto) {},
-	crimson::ct_error::enoent::handle([extent]() -> rewrite_extent_ret {
-	  ceph_assert(extent->has_been_invalidated());
-	  return crimson::ct_error::eagain::make();
-	}),
-	rewrite_extent_ertr::pass_further{},
+	rewrite_extent_iertr::pass_further{},
         /* ENOENT in particular should be impossible */
 	crimson::ct_error::assert_all{
 	  "Invalid error in BtreeLBAManager::rewrite_extent after update_mapping"
@@ -469,23 +462,19 @@ BtreeLBAManager::rewrite_extent_ret BtreeLBAManager::rewrite_extent(
       t,
       nlba_extent->get_node_meta().depth,
       nlba_extent->get_node_meta().begin,
-      nlba_extent->get_paddr()).safe_then(
+      nlba_extent->get_paddr()).si_then(
 	[](auto) {},
-	crimson::ct_error::enoent::handle([extent]() -> rewrite_extent_ret {
-	  ceph_assert(extent->has_been_invalidated());
-	  return crimson::ct_error::eagain::make();
-	}),
-	rewrite_extent_ertr::pass_further{},
+	rewrite_extent_iertr::pass_further{},
 	crimson::ct_error::assert_all{
 	  "Invalid error in BtreeLBAManager::rewrite_extent update_internal_mapping"
 	});
   } else {
-    return rewrite_extent_ertr::now();
+    return rewrite_extent_iertr::now();
   }
 }
 
 BtreeLBAManager::get_physical_extent_if_live_ret
-BtreeLBAManager::get_physical_extent_if_live(
+BtreeLBAManager::_get_physical_extent_if_live(
   Transaction &t,
   extent_types_t type,
   paddr_t addr,
@@ -499,21 +488,21 @@ BtreeLBAManager::get_physical_extent_if_live(
     addr,
     laddr,
     len
-  ).safe_then([=, &t](CachedExtentRef extent) {
-    return get_root(t).safe_then([=, &t](LBANodeRef root) {
+  ).si_then([=, &t](CachedExtentRef extent) {
+    return get_root(t).si_then([=, &t](LBANodeRef root) {
       auto lba_node = extent->cast<LBANode>();
       return root->lookup(
 	op_context_t{cache, pin_set, t},
 	lba_node->get_node_meta().begin,
-	lba_node->get_node_meta().depth).safe_then([=](LBANodeRef c) {
+	lba_node->get_node_meta().depth).si_then([=](LBANodeRef c) {
 	  if (c->get_paddr() == lba_node->get_paddr()) {
 	    return get_physical_extent_if_live_ret(
-	      get_physical_extent_if_live_ertr::ready_future_marker{},
+	      interruptible::ready_future_marker{},
 	      lba_node);
 	  } else {
 	    cache.drop_from_cache(lba_node);
 	    return get_physical_extent_if_live_ret(
-	      get_physical_extent_if_live_ertr::ready_future_marker{},
+	      interruptible::ready_future_marker{},
 	      CachedExtentRef());
 	  }
 	});
@@ -533,11 +522,11 @@ BtreeLBAManager::insert_mapping_ret BtreeLBAManager::insert_mapping(
   laddr_t laddr,
   lba_map_val_t val)
 {
-  auto split = insert_mapping_ertr::future<LBANodeRef>(
-    insert_mapping_ertr::ready_future_marker{},
+  auto split = insert_mapping_iertr::future<LBANodeRef>(
+    interruptible::ready_future_marker{},
     root);
   if (root->at_max_capacity()) {
-    split = cache.get_root(t).safe_then(
+    split = cache.get_root(t).si_then(
       [this, root, laddr, &t](RootBlockRef croot) {
 	logger().debug(
 	  "BtreeLBAManager::insert_mapping: splitting root {}",
@@ -564,7 +553,7 @@ BtreeLBAManager::insert_mapping_ret BtreeLBAManager::insert_mapping(
 	  laddr, nroot->begin(), root);
       });
   }
-  return split.safe_then([this, &t, laddr, val](LBANodeRef node) {
+  return split.si_then([this, &t, laddr, val](LBANodeRef node) {
     return node->insert(
       get_context(t),
       laddr, val);
@@ -584,7 +573,7 @@ BtreeLBAManager::update_refcount_ret BtreeLBAManager::update_refcount(
       ceph_assert((int)out.refcount + delta >= 0);
       out.refcount += delta;
       return out;
-    }).safe_then([](auto result) {
+    }).si_then([](auto result) {
       return ref_update_result_t{
 	result.refcount,
 	result.paddr,
@@ -599,7 +588,7 @@ BtreeLBAManager::update_mapping_ret BtreeLBAManager::update_mapping(
   update_func_t &&f)
 {
   return get_root(t
-  ).safe_then([this, f=std::move(f), &t, addr](LBANodeRef root) mutable {
+  ).si_then([this, f=std::move(f), &t, addr](LBANodeRef root) mutable {
     return root->mutate_mapping(
       get_context(t),
       addr,
@@ -614,7 +603,7 @@ BtreeLBAManager::update_internal_mapping(
   laddr_t laddr,
   paddr_t paddr)
 {
-  return cache.get_root(t).safe_then([=, &t](RootBlockRef croot) {
+  return cache.get_root(t).si_then([=, &t](RootBlockRef croot) {
     if (depth == croot->get_root().lba_root.get_depth()) {
       logger().debug(
 	"update_internal_mapping: updating lba root to: {}->{}",
@@ -628,7 +617,7 @@ BtreeLBAManager::update_internal_mapping(
       auto old_paddr = croot->get_root().lba_root.get_location();
       croot->get_root().lba_root.set_location(paddr);
       return update_internal_mapping_ret(
-	update_internal_mapping_ertr::ready_future_marker{},
+	interruptible::ready_future_marker{},
 	old_paddr);
     } else {
       logger().debug(
@@ -641,7 +630,7 @@ BtreeLBAManager::update_internal_mapping(
 	croot,
 	croot->get_root().lba_root.get_depth(),
 	croot->get_root().lba_root.get_location(),
-	paddr_t()).safe_then([=, &t](LBANodeRef broot) {
+	paddr_t()).si_then([=, &t](LBANodeRef broot) {
 	  return broot->mutate_internal_address(
 	    get_context(t),
 	    depth,
diff --git a/src/crimson/os/seastore/lba_manager/btree/btree_lba_manager.h b/src/crimson/os/seastore/lba_manager/btree/btree_lba_manager.h
index 91a1f99c02240..17df62dc079b5 100644
--- a/src/crimson/os/seastore/lba_manager/btree/btree_lba_manager.h
+++ b/src/crimson/os/seastore/lba_manager/btree/btree_lba_manager.h
@@ -50,40 +50,40 @@ public:
   mkfs_ret mkfs(
     Transaction &t) final;
 
-  get_mappings_ret get_mappings(
+  get_mappings_ret _get_mappings(
     Transaction &t,
     laddr_t offset, extent_len_t length) final;
 
-  get_mappings_ret get_mappings(
+  get_mappings_ret _get_mappings(
     Transaction &t,
     laddr_list_t &&list) final;
 
-  get_mapping_ret get_mapping(
+  get_mapping_ret _get_mapping(
     Transaction &t,
     laddr_t offset) final;
 
-  find_hole_ret find_hole(
+  find_hole_ret _find_hole(
     Transaction &t,
     laddr_t hint,
     extent_len_t) final;
 
-  alloc_extent_ret alloc_extent(
+  alloc_extent_ret _alloc_extent(
     Transaction &t,
     laddr_t hint,
     extent_len_t len,
     paddr_t addr) final;
 
-  set_extent_ret set_extent(
+  set_extent_ret _set_extent(
     Transaction &t,
     laddr_t off, extent_len_t len, paddr_t addr) final;
 
-  ref_ret decref_extent(
+  ref_ret _decref_extent(
     Transaction &t,
     laddr_t addr) final {
     return update_refcount(t, addr, -1);
   }
 
-  ref_ret incref_extent(
+  ref_ret _incref_extent(
     Transaction &t,
     laddr_t addr) final {
     return update_refcount(t, addr, 1);
@@ -92,25 +92,25 @@ public:
   void complete_transaction(
     Transaction &t) final;
 
-  init_cached_extent_ret init_cached_extent(
+  init_cached_extent_ret _init_cached_extent(
     Transaction &t,
     CachedExtentRef e) final;
 
-  scan_mappings_ret scan_mappings(
+  scan_mappings_ret _scan_mappings(
     Transaction &t,
     laddr_t begin,
     laddr_t end,
     scan_mappings_func_t &&f) final;
 
-  scan_mapped_space_ret scan_mapped_space(
+  scan_mapped_space_ret _scan_mapped_space(
     Transaction &t,
     scan_mapped_space_func_t &&f) final;
 
-  rewrite_extent_ret rewrite_extent(
+  rewrite_extent_ret _rewrite_extent(
     Transaction &t,
-    CachedExtentRef extent);
+    CachedExtentRef extent) final;
 
-  get_physical_extent_if_live_ret get_physical_extent_if_live(
+  get_physical_extent_if_live_ret _get_physical_extent_if_live(
     Transaction &t,
     extent_types_t type,
     paddr_t addr,
@@ -126,7 +126,7 @@ public:
   ~BtreeLBAManager();
 private:
   SegmentManager &segment_manager;
-  InterruptedCache cache;
+  Cache &cache;
 
   btree_pin_set_t pin_set;
 
@@ -142,8 +142,8 @@ private:
    *
    * Get a reference to the root LBANode.
    */
-  using get_root_ertr = base_ertr;
-  using get_root_ret = get_root_ertr::future<LBANodeRef>;
+  using get_root_iertr = base_iertr;
+  using get_root_ret = get_root_iertr::future<LBANodeRef>;
   get_root_ret get_root(Transaction &);
 
   /**
@@ -151,8 +151,8 @@ private:
    *
    * Insert a lba mapping into the tree
    */
-  using insert_mapping_ertr = base_ertr;
-  using insert_mapping_ret = insert_mapping_ertr::future<LBAPinRef>;
+  using insert_mapping_iertr = base_iertr;
+  using insert_mapping_ret = insert_mapping_iertr::future<LBAPinRef>;
   insert_mapping_ret insert_mapping(
     Transaction &t,   ///< [in,out] transaction
     LBANodeRef root,  ///< [in] root node
@@ -176,15 +176,15 @@ private:
    *
    * Updates mapping, removes if f returns nullopt
    */
-  using update_mapping_ertr = ref_ertr;
-  using update_mapping_ret = ref_ertr::future<lba_map_val_t>;
+  using update_mapping_iertr = ref_iertr;
+  using update_mapping_ret = ref_iertr::future<lba_map_val_t>;
   using update_func_t = LBANode::mutate_func_t;
   update_mapping_ret update_mapping(
     Transaction &t,
     laddr_t addr,
     update_func_t &&f);
 
-  using update_internal_mapping_ertr = LBANode::mutate_internal_address_ertr;
+  using update_internal_mapping_iertr = LBANode::mutate_internal_address_iertr;
   using update_internal_mapping_ret = LBANode::mutate_internal_address_ret;
   update_internal_mapping_ret update_internal_mapping(
     Transaction &t,
diff --git a/src/crimson/os/seastore/lba_manager/btree/lba_btree_node.h b/src/crimson/os/seastore/lba_manager/btree/lba_btree_node.h
index 9c2b498217b69..053bf27b2f6c9 100644
--- a/src/crimson/os/seastore/lba_manager/btree/lba_btree_node.h
+++ b/src/crimson/os/seastore/lba_manager/btree/lba_btree_node.h
@@ -13,10 +13,10 @@
 
 namespace crimson::os::seastore::lba_manager::btree {
 
-using base_ertr = LBAManager::base_ertr;
+using base_iertr = LBAManager::base_iertr;
 
 struct op_context_t {
-  InterruptedCache cache;
+  Cache &cache;
   btree_pin_set_t &pins;
   Transaction &trans;
 };
@@ -65,8 +65,8 @@ struct LBANode : CachedExtent {
    * Returns the node at the specified depth responsible
    * for laddr
    */
-  using lookup_ertr = base_ertr;
-  using lookup_ret = lookup_ertr::future<LBANodeRef>;
+  using lookup_iertr = base_iertr;
+  using lookup_ret = lookup_iertr::future<LBANodeRef>;
   virtual lookup_ret lookup(
     op_context_t c,
     laddr_t addr,
@@ -77,7 +77,7 @@ struct LBANode : CachedExtent {
    *
    * Returns mappings within range [addr, addr+len)
    */
-  using lookup_range_ertr = LBAManager::get_mappings_ertr;
+  using lookup_range_iertr = LBAManager::get_mappings_iertr;
   using lookup_range_ret = LBAManager::get_mappings_ret;
   virtual lookup_range_ret lookup_range(
     op_context_t c,
@@ -89,7 +89,7 @@ struct LBANode : CachedExtent {
    *
    * Returns the mapping at addr
    */
-  using lookup_pin_ertr = LBAManager::get_mapping_ertr;
+  using lookup_pin_iertr = LBAManager::get_mapping_iertr;
   using lookup_pin_ret = LBAManager::get_mapping_ret;
   virtual lookup_pin_ret lookup_pin(
     op_context_t c,
@@ -103,8 +103,8 @@ struct LBANode : CachedExtent {
    *
    * Precondition: !at_max_capacity()
    */
-  using insert_ertr = base_ertr;
-  using insert_ret = insert_ertr::future<LBAPinRef>;
+  using insert_iertr = base_iertr;
+  using insert_ret = insert_iertr::future<LBAPinRef>;
   virtual insert_ret insert(
     op_context_t c,
     laddr_t laddr,
@@ -117,8 +117,8 @@ struct LBANode : CachedExtent {
    *
    * @return addr of hole, L_ADDR_NULL if unfound
    */
-  using find_hole_ertr = base_ertr;
-  using find_hole_ret = find_hole_ertr::future<laddr_t>;
+  using find_hole_iertr = base_iertr;
+  using find_hole_ret = find_hole_iertr::future<laddr_t>;
   virtual find_hole_ret find_hole(
     op_context_t c,
     laddr_t min,
@@ -130,7 +130,7 @@ struct LBANode : CachedExtent {
    *
    * Call f for all mappings in [begin, end)
    */
-  using scan_mappings_ertr = LBAManager::scan_mappings_ertr;
+  using scan_mappings_iertr = LBAManager::scan_mappings_iertr;
   using scan_mappings_ret = LBAManager::scan_mappings_ret;
   using scan_mappings_func_t = LBAManager::scan_mappings_func_t;
   virtual scan_mappings_ret scan_mappings(
@@ -139,7 +139,7 @@ struct LBANode : CachedExtent {
     laddr_t end,
     scan_mappings_func_t &f) = 0;
 
-  using scan_mapped_space_ertr = LBAManager::scan_mapped_space_ertr;
+  using scan_mapped_space_iertr = LBAManager::scan_mapped_space_iertr;
   using scan_mapped_space_ret = LBAManager::scan_mapped_space_ret;
   using scan_mapped_space_func_t = LBAManager::scan_mapped_space_func_t;
   virtual scan_mapped_space_ret scan_mapped_space(
@@ -157,10 +157,10 @@ struct LBANode : CachedExtent {
    *
    * Precondition: !at_min_capacity()
    */
-  using mutate_mapping_ertr = base_ertr::extend<
+  using mutate_mapping_iertr = base_iertr::extend<
     crimson::ct_error::enoent             ///< mapping does not exist
     >;
-  using mutate_mapping_ret = mutate_mapping_ertr::future<
+  using mutate_mapping_ret = mutate_mapping_iertr::future<
     lba_map_val_t>;
   using mutate_func_t = std::function<
     lba_map_val_t(const lba_map_val_t &v)
@@ -182,10 +182,10 @@ struct LBANode : CachedExtent {
    * updates the mapping to paddr.  Returns previous paddr
    * (for debugging purposes).
    */
-  using mutate_internal_address_ertr = base_ertr::extend<
+  using mutate_internal_address_iertr = base_iertr::extend<
     crimson::ct_error::enoent             ///< mapping does not exist
     >;
-  using mutate_internal_address_ret = mutate_internal_address_ertr::future<
+  using mutate_internal_address_ret = mutate_internal_address_iertr::future<
     paddr_t>;
   virtual mutate_internal_address_ret mutate_internal_address(
     op_context_t c,
@@ -265,8 +265,8 @@ using LBANodeRef = LBANode::LBANodeRef;
  *
  * Fetches node at depth of the appropriate type.
  */
-using get_lba_node_ertr = base_ertr;
-using get_lba_node_ret = get_lba_node_ertr::future<LBANodeRef>;
+using get_lba_node_iertr = base_iertr;
+using get_lba_node_ret = get_lba_node_iertr::future<LBANodeRef>;
 get_lba_node_ret get_lba_btree_extent(
   op_context_t c, ///< [in] context structure
   CachedExtentRef parent, ///< [in] paddr ref source
diff --git a/src/crimson/os/seastore/lba_manager/btree/lba_btree_node_impl.cc b/src/crimson/os/seastore/lba_manager/btree/lba_btree_node_impl.cc
index 23955e23563bf..9d121ec7129b7 100644
--- a/src/crimson/os/seastore/lba_manager/btree/lba_btree_node_impl.cc
+++ b/src/crimson/os/seastore/lba_manager/btree/lba_btree_node_impl.cc
@@ -34,7 +34,7 @@ LBAInternalNode::lookup_ret LBAInternalNode::lookup(
   auto meta = get_meta();
   if (depth == get_meta().depth) {
     return lookup_ret(
-      lookup_ertr::ready_future_marker{},
+      interruptible::ready_future_marker{},
       this);
   }
   assert(meta.begin <= addr);
@@ -48,7 +48,7 @@ LBAInternalNode::lookup_ret LBAInternalNode::lookup(
     this,
     meta.depth - 1,
     iter->get_val(),
-    get_paddr()).safe_then([c, addr, depth](auto child) {
+    get_paddr()).si_then([c, addr, depth](auto child) {
       return child->lookup(c, addr, depth);
     }).finally([ref=LBANodeRef(this)] {});
 }
@@ -61,28 +61,28 @@ LBAInternalNode::lookup_range_ret LBAInternalNode::lookup_range(
   auto [begin, end] = bound(addr, addr + len);
   auto result_up = std::make_unique<lba_pin_list_t>();
   auto &result = *result_up;
-  return crimson::do_for_each(
+  return trans_intr::do_for_each(
     std::move(begin),
     std::move(end),
-    [this, c, &result, addr, len](const auto &val) mutable {
+    [this, c, &result, addr, len](const auto &val) {
       return get_lba_btree_extent(
 	c,
 	this,
 	get_meta().depth - 1,
 	val.get_val(),
-	get_paddr()).safe_then(
-	  [c, &result, addr, len](auto extent) mutable {
+	get_paddr()).si_then(
+	  [c, &result, addr, len](auto extent) {
 	    return extent->lookup_range(
 	      c,
 	      addr,
-	      len).safe_then(
-		[&result](auto pin_list) mutable {
+	      len).si_then(
+		[&result](auto pin_list) {
 		  result.splice(result.end(), pin_list,
 				pin_list.begin(), pin_list.end());
 		});
 	  });
-    }).safe_then([result=std::move(result_up), ref=LBANodeRef(this)] {
-      return lookup_range_ertr::make_ready_future<lba_pin_list_t>(
+    }).si_then([result=std::move(result_up), ref=LBANodeRef(this)] {
+      return lookup_range_iertr::make_ready_future<lba_pin_list_t>(
 	std::move(*result));
     });
 }
@@ -98,7 +98,7 @@ LBAInternalNode::lookup_pin_ret LBAInternalNode::lookup_pin(
     get_meta().depth - 1,
     iter->get_val(),
     get_paddr()
-  ).safe_then([c, addr] (LBANodeRef extent) {
+  ).si_then([c, addr](LBANodeRef extent) {
     return extent->lookup_pin(c, addr);
   }).finally([ref=LBANodeRef(this)] {});
 }
@@ -114,13 +114,13 @@ LBAInternalNode::insert_ret LBAInternalNode::insert(
     this,
     get_meta().depth - 1,
     insertion_pt->get_val(),
-    get_paddr()).safe_then(
+    get_paddr()).si_then(
       [this, insertion_pt, c, laddr, val=std::move(val)](
 	auto extent) mutable {
 	return extent->at_max_capacity() ?
 	  split_entry(c, laddr, insertion_pt, extent) :
-	  insert_ertr::make_ready_future<LBANodeRef>(std::move(extent));
-      }).safe_then([c, laddr, val=std::move(val)](
+	  insert_iertr::make_ready_future<LBANodeRef>(std::move(extent));
+      }).si_then([c, laddr, val=std::move(val)](
 		     LBANodeRef extent) mutable {
 	return extent->insert(c, laddr, val);
       });
@@ -151,7 +151,7 @@ LBAInternalNode::mutate_mapping_ret LBAInternalNode::mutate_mapping_internal(
     get_meta().depth - 1,
     mutation_pt->get_val(),
     get_paddr()
-  ).safe_then([=](LBANodeRef extent) {
+  ).si_then([=](LBANodeRef extent) {
     if (extent->at_min_capacity() && get_size() > 1) {
       return merge_entry(
 	c,
@@ -160,10 +160,10 @@ LBAInternalNode::mutate_mapping_ret LBAInternalNode::mutate_mapping_internal(
 	extent,
 	is_root);
     } else {
-      return merge_ertr::make_ready_future<LBANodeRef>(
+      return merge_iertr::make_ready_future<LBANodeRef>(
 	std::move(extent));
     }
-  }).safe_then([c, laddr, f=std::move(f)](LBANodeRef extent) mutable {
+  }).si_then([c, laddr, f=std::move(f)](LBANodeRef extent) mutable {
     return extent->mutate_mapping_internal(c, laddr, false, std::move(f));
   });
 }
@@ -201,7 +201,7 @@ LBAInternalNode::mutate_internal_address_ret LBAInternalNode::mutate_internal_ad
       maybe_get_delta_buffer());
 
     return mutate_internal_address_ret(
-      mutate_internal_address_ertr::ready_future_marker{},
+      interruptible::ready_future_marker{},
       old_paddr
     );
   } else {
@@ -212,7 +212,7 @@ LBAInternalNode::mutate_internal_address_ret LBAInternalNode::mutate_internal_ad
       get_meta().depth - 1,
       iter->get_val(),
       get_paddr()
-    ).safe_then([=](auto node) {
+    ).si_then([=](auto node) {
       return node->mutate_internal_address(
 	c,
 	depth,
@@ -236,8 +236,8 @@ LBAInternalNode::find_hole_ret LBAInternalNode::find_hole(
     begin,
     L_ADDR_NULL,
     [this, c, min_addr, len, end=end](auto &i, auto &ret) {
-      return crimson::repeat([=, &i, &ret]()
-        -> find_hole_ertr::future<seastar::stop_iteration> {
+      return trans_intr::repeat([=, &i, &ret]()
+        -> find_hole_iertr::future<seastar::stop_iteration> {
 	if (i == end) {
 	  return seastar::make_ready_future<seastar::stop_iteration>(
 	    seastar::stop_iteration::yes);
@@ -248,13 +248,13 @@ LBAInternalNode::find_hole_ret LBAInternalNode::find_hole(
 	  get_meta().depth - 1,
 	  i->get_val(),
 	  get_paddr()
-	).safe_then([=, &i](auto extent) mutable {
+	).si_then([=, &i](auto extent) mutable {
 	  auto lb = std::max(min_addr, i->get_key());
 	  auto ub = i->get_next_key_or_max();
 	  logger().debug("LBAInternalNode::find_hole extent {} lb {} ub {}",
 			 *extent, lb, ub);
 	  return extent->find_hole(c, lb, ub, len);
-	}).safe_then([&i, &ret](auto addr) mutable {
+	}).si_then([&i, &ret](auto addr) {
 	  if (addr == L_ADDR_NULL) {
 	    ++i;
 	    return seastar::make_ready_future<seastar::stop_iteration>(
@@ -265,10 +265,10 @@ LBAInternalNode::find_hole_ret LBAInternalNode::find_hole(
 	      seastar::stop_iteration::yes);
 	  }
 	});
-      }).safe_then([&ret, ref=LBANodeRef(this)] {
-	return ret;
-      });
-  });
+	}).si_then([&ret, ref=LBANodeRef(this)]() {
+	  return ret;
+	});
+    });
 }
 
 LBAInternalNode::scan_mappings_ret LBAInternalNode::scan_mappings(
@@ -278,7 +278,7 @@ LBAInternalNode::scan_mappings_ret LBAInternalNode::scan_mappings(
   scan_mappings_func_t &f)
 {
   auto [biter, eiter] = bound(begin, end);
-  return crimson::do_for_each(
+  return trans_intr::do_for_each(
     std::move(biter),
     std::move(eiter),
     [=, &f](auto &viter) {
@@ -287,10 +287,10 @@ LBAInternalNode::scan_mappings_ret LBAInternalNode::scan_mappings(
 	this,
 	get_meta().depth - 1,
 	viter->get_val(),
-	get_paddr()).safe_then([=, &f](auto child) {
+	get_paddr()).si_then([=, &f](auto child) {
 	  return child->scan_mappings(c, begin, end, f);
 	});
-    }).safe_then([ref=LBANodeRef(this)]{});
+    }).si_then([ref=LBANodeRef(this)] {});
 }
 
 LBAInternalNode::scan_mapped_space_ret LBAInternalNode::scan_mapped_space(
@@ -298,7 +298,7 @@ LBAInternalNode::scan_mapped_space_ret LBAInternalNode::scan_mapped_space(
   scan_mapped_space_func_t &f)
 {
   f(get_paddr(), get_length());
-  return crimson::do_for_each(
+  return trans_intr::do_for_each(
     begin(), end(),
     [=, &f](auto &viter) {
       return get_lba_btree_extent(
@@ -306,10 +306,10 @@ LBAInternalNode::scan_mapped_space_ret LBAInternalNode::scan_mapped_space(
 	this,
 	get_meta().depth - 1,
 	viter->get_val(),
-	get_paddr()).safe_then([=, &f](auto child) {
+	get_paddr()).si_then([=, &f](auto child) {
 	  return child->scan_mapped_space(c, f);
 	});
-    }).safe_then([ref=LBANodeRef(this)]{});
+    }).si_then([ref=LBANodeRef(this)]{});
 }
 
 
@@ -363,7 +363,7 @@ LBAInternalNode::split_entry(
     *left,
     *right);
 
-  return split_ertr::make_ready_future<LBANodeRef>(
+  return split_iertr::make_ready_future<LBANodeRef>(
     pivot > addr ? left : right
   );
 }
@@ -394,7 +394,7 @@ LBAInternalNode::merge_entry(
     get_meta().depth - 1,
     donor_iter->get_val(),
     get_paddr()
-  ).safe_then([=](auto donor) mutable {
+  ).si_then([=](auto donor) mutable {
     auto [l, r] = donor_is_left ?
       std::make_pair(donor, entry) : std::make_pair(entry, donor);
     auto [liter, riter] = donor_is_left ?
@@ -414,7 +414,7 @@ LBAInternalNode::merge_entry(
       c.cache.retire_extent(c.trans, r);
 
       if (is_root && get_size() == 1) {
-	return c.cache.get_root(c.trans).safe_then([=](RootBlockRef croot) {
+	return c.cache.get_root(c.trans).si_then([=](RootBlockRef croot) {
 	  {
 	    auto mut_croot = c.cache.duplicate_for_write(c.trans, croot);
 	    croot = mut_croot->cast<RootBlock>();
@@ -428,10 +428,10 @@ LBAInternalNode::merge_entry(
 	    *this,
 	    new_root_addr);
 	  c.cache.retire_extent(c.trans, this);
-	  return merge_ertr::make_ready_future<LBANodeRef>(replacement);
+	  return merge_iertr::make_ready_future<LBANodeRef>(replacement);
 	});
       } else {
-	return merge_ertr::make_ready_future<LBANodeRef>(replacement);
+	return merge_iertr::make_ready_future<LBANodeRef>(replacement);
       }
     } else {
       logger().debug(
@@ -456,7 +456,7 @@ LBAInternalNode::merge_entry(
 
       c.cache.retire_extent(c.trans, l);
       c.cache.retire_extent(c.trans, r);
-      return merge_ertr::make_ready_future<LBANodeRef>(
+      return merge_iertr::make_ready_future<LBANodeRef>(
 	addr >= pivot ? replacement_r : replacement_l
       );
     }
@@ -502,7 +502,7 @@ LBALeafNode::lookup_range_ret LBALeafNode::lookup_range(
 	val.paddr.maybe_relative_to(get_paddr()),
 	lba_node_meta_t{ begin, begin + val.len, 0}));
   }
-  return lookup_range_ertr::make_ready_future<lba_pin_list_t>(
+  return lookup_range_iertr::make_ready_future<lba_pin_list_t>(
     std::move(ret));
 }
 
@@ -518,7 +518,7 @@ LBALeafNode::lookup_pin_ret LBALeafNode::lookup_pin(
   auto val = iter->get_val();
   auto begin = iter->get_key();
   return lookup_pin_ret(
-    lookup_pin_ertr::ready_future_marker{},
+    interruptible::ready_future_marker{},
     std::make_unique<BtreeLBAPin>(
       this,
       val.paddr.maybe_relative_to(get_paddr()),
@@ -554,7 +554,7 @@ LBALeafNode::insert_ret LBALeafNode::insert(
     insert_pt.get_val().paddr);
   auto begin = insert_pt.get_key();
   return insert_ret(
-    insert_ertr::ready_future_marker{},
+    interruptible::ready_future_marker{},
     std::make_unique<BtreeLBAPin>(
       this,
       val.paddr.maybe_relative_to(get_paddr()),
@@ -604,12 +604,12 @@ LBALeafNode::mutate_mapping_ret LBALeafNode::mutate_mapping_internal(
   if (mutated.refcount > 0) {
     journal_update(mutation_pt, mutated, maybe_get_delta_buffer());
     return mutate_mapping_ret(
-      mutate_mapping_ertr::ready_future_marker{},
+      interruptible::ready_future_marker{},
       mutated);
   } else {
     journal_remove(mutation_pt, maybe_get_delta_buffer());
     return mutate_mapping_ret(
-      mutate_mapping_ertr::ready_future_marker{},
+      interruptible::ready_future_marker{},
       mutated);
   }
 }
@@ -622,7 +622,7 @@ LBALeafNode::mutate_internal_address_ret LBALeafNode::mutate_internal_address(
 {
   ceph_assert(0 == "Impossible");
   return mutate_internal_address_ret(
-    mutate_internal_address_ertr::ready_future_marker{},
+    interruptible::ready_future_marker{},
     paddr);
 }
 
@@ -640,7 +640,7 @@ LBALeafNode::find_hole_ret LBALeafNode::find_hole(
     auto ub = i->get_key();
     if (min + len <= ub) {
       return find_hole_ret(
-	find_hole_ertr::ready_future_marker{},
+	interruptible::ready_future_marker{},
 	min);
     } else {
       min = i->get_key() + i->get_val().len;
@@ -648,11 +648,11 @@ LBALeafNode::find_hole_ret LBALeafNode::find_hole(
   }
   if (min + len <= max) {
     return find_hole_ret(
-      find_hole_ertr::ready_future_marker{},
+      interruptible::ready_future_marker{},
       min);
   } else {
     return find_hole_ret(
-      find_hole_ertr::ready_future_marker{},
+      interruptible::ready_future_marker{},
       L_ADDR_MAX);
   }
 }
@@ -668,7 +668,7 @@ LBALeafNode::scan_mappings_ret LBALeafNode::scan_mappings(
     auto val = i->get_val();
     f(i->get_key(), val.paddr, val.len);
   }
-  return scan_mappings_ertr::now();
+  return scan_mappings_iertr::now();
 }
 
 LBALeafNode::scan_mapped_space_ret LBALeafNode::scan_mapped_space(
@@ -680,7 +680,7 @@ LBALeafNode::scan_mapped_space_ret LBALeafNode::scan_mapped_space(
     auto val = i->get_val();
     f(val.paddr, val.len);
   }
-  return scan_mappings_ertr::now();
+  return scan_mappings_iertr::now();
 }
 
 
@@ -722,22 +722,20 @@ get_lba_node_ret get_lba_btree_extent(
     return c.cache.get_extent<LBAInternalNode>(
       c.trans,
       offset,
-      LBA_BLOCK_SIZE).safe_then([c, parent](auto ret)
+      LBA_BLOCK_SIZE).si_then([c, parent](auto ret)
 				-> get_lba_node_ret {
 	auto meta = ret->get_meta();
 	if (ret->get_size()) {
 	  ceph_assert(meta.begin <= ret->begin()->get_key());
 	  ceph_assert(meta.end > (ret->end() - 1)->get_key());
 	}
-	if (parent->has_been_invalidated() || ret->has_been_invalidated()) {
-	  return crimson::ct_error::eagain::make();
-	}
+	assert(!(parent->has_been_invalidated() || ret->has_been_invalidated()));
 	if (!ret->is_pending() && !ret->pin.is_linked()) {
 	  ret->pin.set_range(meta);
 	  c.pins.add_pin(ret->pin);
 	}
 	return get_lba_node_ret(
-	  get_lba_node_ertr::ready_future_marker{},
+	  interruptible::ready_future_marker{},
 	  LBANodeRef(ret.detach(), /* add_ref = */ false));
       });
   } else {
@@ -748,7 +746,7 @@ get_lba_node_ret get_lba_btree_extent(
     return c.cache.get_extent<LBALeafNode>(
       c.trans,
       offset,
-      LBA_BLOCK_SIZE).safe_then([offset, c, parent](auto ret)
+      LBA_BLOCK_SIZE).si_then([offset, c, parent](auto ret)
 				-> get_lba_node_ret {
 	logger().debug(
 	  "get_lba_btree_extent: read leaf at offset {} {}, parent {}",
@@ -760,15 +758,13 @@ get_lba_node_ret get_lba_btree_extent(
 	  ceph_assert(meta.begin <= ret->begin()->get_key());
 	  ceph_assert(meta.end > (ret->end() - 1)->get_key());
 	}
-	if (parent->has_been_invalidated() || ret->has_been_invalidated()) {
-	  return crimson::ct_error::eagain::make();
-	}
+	assert(!(parent->has_been_invalidated() || ret->has_been_invalidated()));
 	if (!ret->is_pending() && !ret->pin.is_linked()) {
 	  ret->pin.set_range(meta);
 	  c.pins.add_pin(ret->pin);
 	}
 	return get_lba_node_ret(
-	  get_lba_node_ertr::ready_future_marker{},
+	  interruptible::ready_future_marker{},
 	  LBANodeRef(ret.detach(), /* add_ref = */ false));
       });
   }
diff --git a/src/crimson/os/seastore/lba_manager/btree/lba_btree_node_impl.h b/src/crimson/os/seastore/lba_manager/btree/lba_btree_node_impl.h
index 07385e2ffaa4d..a4bb529f18fa4 100644
--- a/src/crimson/os/seastore/lba_manager/btree/lba_btree_node_impl.h
+++ b/src/crimson/os/seastore/lba_manager/btree/lba_btree_node_impl.h
@@ -275,16 +275,16 @@ struct LBAInternalNode
     return std::make_pair(retl, retr);
   }
 
-  using split_ertr = base_ertr;
-  using split_ret = split_ertr::future<LBANodeRef>;
+  using split_iertr = base_iertr;
+  using split_ret = split_iertr::future<LBANodeRef>;
   split_ret split_entry(
     op_context_t c,
     laddr_t addr,
     internal_iterator_t,
     LBANodeRef entry);
 
-  using merge_ertr = base_ertr;
-  using merge_ret = merge_ertr::future<LBANodeRef>;
+  using merge_iertr = base_iertr;
+  using merge_ret = merge_iertr::future<LBANodeRef>;
   merge_ret merge_entry(
     op_context_t c,
     laddr_t addr,
@@ -369,7 +369,7 @@ struct LBALeafNode
   lookup_ret lookup(op_context_t c, laddr_t addr, depth_t depth) final
   {
     return lookup_ret(
-      lookup_ertr::ready_future_marker{},
+      interruptible::ready_future_marker{},
       this);
   }
 
diff --git a/src/crimson/os/seastore/transaction_manager.h b/src/crimson/os/seastore/transaction_manager.h
index 8f8ba5d9bdff4..c2aeae5f97030 100644
--- a/src/crimson/os/seastore/transaction_manager.h
+++ b/src/crimson/os/seastore/transaction_manager.h
@@ -127,7 +127,7 @@ public:
    * Get the logical pin at offset
    */
   using get_pin_ertr = LBAManager::get_mapping_ertr;
-  using get_pin_ret = LBAManager::get_mapping_ret;
+  using get_pin_ret = LBAManager::get_mapping_ertr::future<LBAPinRef>;
   get_pin_ret get_pin(
     Transaction &t,
     laddr_t offset) {
@@ -337,7 +337,9 @@ public:
   }
 
   using find_hole_ertr = LBAManager::find_hole_ertr;
-  using find_hole_ret = LBAManager::find_hole_ret;
+  using find_hole_ret = LBAManager::find_hole_ertr::future<
+    std::pair<laddr_t, extent_len_t>
+    >;
   find_hole_ret find_hole(
     Transaction &t,
     laddr_t hint,