crimson: adjust all void-returning handlers to either return values or

switch to errorator::asserts

Signed-off-by: Xuehan Xu <xuxuehan@qianxin.com>
(cherry picked from commit 2f2b4f6170dbbd24c404d2bf58170e0818df8c80)

diff --git a/src/crimson/os/cyanstore/cyan_store.h b/src/crimson/os/cyanstore/cyan_store.h
index 3258deb231e89394a6b9fc0f1134533e375e7b13..99583d07d36a78bb17f828693dddf4b3e6253404 100644 (file)
--- a/src/crimson/os/cyanstore/cyan_store.h
+++ b/src/crimson/os/cyanstore/cyan_store.h
@@ -185,11 +185,10 @@ public:
     return shard_stores.invoke_on_all(
       [](auto &local_store) {
       return local_store.mount().handle_error(
-      crimson::stateful_ec::handle([](const auto& ec) {
+      crimson::stateful_ec::assert_failure([](const auto& ec) {
         crimson::get_logger(ceph_subsys_cyanstore).error(
            "error mounting cyanstore: ({}) {}",
             ec.value(), ec.message());
-        std::exit(EXIT_FAILURE);
       }));
     });
   }

diff --git a/src/crimson/os/seastore/async_cleaner.h b/src/crimson/os/seastore/async_cleaner.h
index 1c94745d820c2196999c183678e12c8deea7d105..40dda034daaaf2ed3aa5f4aba1cfd01c46d7e247 100644 (file)
--- a/src/crimson/os/seastore/async_cleaner.h
+++ b/src/crimson/os/seastore/async_cleaner.h
@@ -299,9 +299,7 @@ public:
     return do_with_transaction_intr<Func, true>(
         Transaction::src_t::READ, name, std::forward<Func>(f)
     ).handle_error(
-      crimson::ct_error::eagain::handle([] {
-        ceph_assert(0 == "eagain impossible");
-      }),
+      crimson::ct_error::eagain::assert_failure{"unexpected eagain"},
       crimson::ct_error::pass_further_all{}
     );
   }

diff --git a/src/crimson/os/seastore/journal/record_submitter.cc b/src/crimson/os/seastore/journal/record_submitter.cc
index 5ca53b436d51b57312892a22f0fd7fe1ed94d49c..5c892dcee22202a3b5d6a36c6487e9650debb5a3 100644 (file)
--- a/src/crimson/os/seastore/journal/record_submitter.cc
+++ b/src/crimson/os/seastore/journal/record_submitter.cc
@@ -255,6 +255,7 @@ RecordSubmitter::roll_segment()
           has_io_error = true;
           wait_available_promise->set_value();
           wait_available_promise.reset();
+          return seastar::now();
         })
       ).handle_exception([FNAME, this](auto e) {
         ERROR("{} got exception {}, available", get_name(), e);
@@ -522,6 +523,7 @@ void RecordSubmitter::flush_current_batch()
       ERROR("{} {} records, {}, got error {}",
             get_name(), num, sizes, e);
       finish_submit_batch(p_batch, std::nullopt);
+      return seastar::now();
     })
   ).handle_exception([this, p_batch, FNAME, num, sizes=sizes](auto e) {
     ERROR("{} {} records, {}, got exception {}",

diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/node.cc b/src/crimson/os/seastore/onode_manager/staged-fltree/node.cc
index 6f08f4d3c48532bfac5fa643ef72bbfd26548e17..ec566ac03ccc5a36a8493649f7dd51a90314b249 100644 (file)
--- a/src/crimson/os/seastore/onode_manager/staged-fltree/node.cc
+++ b/src/crimson/os/seastore/onode_manager/staged-fltree/node.cc
@@ -428,9 +428,8 @@ eagain_ifuture<Ref<Node>> Node::load_root(context_t c, RootNodeTracker& root_tra
   return c.nm.get_super(c.t, root_tracker
   ).handle_error_interruptible(
     eagain_iertr::pass_further{},
-    crimson::ct_error::input_output_error::handle([FNAME, c] {
+    crimson::ct_error::input_output_error::assert_failure([FNAME, c] {
       ERRORT("EIO during get_super()", c.t);
-      ceph_abort("fatal error");
     })
   ).si_then([c, &root_tracker, FNAME](auto&& _super) {
     assert(_super);
@@ -692,29 +691,25 @@ eagain_ifuture<Ref<Node>> Node::load(
   return c.nm.read_extent(c.t, addr
   ).handle_error_interruptible(
     eagain_iertr::pass_further{},
-    crimson::ct_error::input_output_error::handle(
+    crimson::ct_error::input_output_error::assert_failure(
         [FNAME, c, addr, expect_is_level_tail] {
       ERRORT("EIO -- addr={:x}, is_level_tail={}",
              c.t, addr, expect_is_level_tail);
-      ceph_abort("fatal error");
     }),
-    crimson::ct_error::invarg::handle(
+    crimson::ct_error::invarg::assert_failure(
         [FNAME, c, addr, expect_is_level_tail] {
       ERRORT("EINVAL -- addr={:x}, is_level_tail={}",
              c.t, addr, expect_is_level_tail);
-      ceph_abort("fatal error");
     }),
-    crimson::ct_error::enoent::handle(
+    crimson::ct_error::enoent::assert_failure(
         [FNAME, c, addr, expect_is_level_tail] {
       ERRORT("ENOENT -- addr={:x}, is_level_tail={}",
              c.t, addr, expect_is_level_tail);
-      ceph_abort("fatal error");
     }),
-    crimson::ct_error::erange::handle(
+    crimson::ct_error::erange::assert_failure(
         [FNAME, c, addr, expect_is_level_tail] {
       ERRORT("ERANGE -- addr={:x}, is_level_tail={}",
              c.t, addr, expect_is_level_tail);
-      ceph_abort("fatal error");
     })
   ).si_then([FNAME, c, addr, expect_is_level_tail](auto extent)
              -> eagain_ifuture<Ref<Node>> {
@@ -2150,9 +2145,8 @@ eagain_ifuture<Ref<LeafNode>> LeafNode::allocate_root(
     return c.nm.get_super(c.t, root_tracker
     ).handle_error_interruptible(
       eagain_iertr::pass_further{},
-      crimson::ct_error::input_output_error::handle([FNAME, c] {
+      crimson::ct_error::input_output_error::assert_failure([FNAME, c] {
         ERRORT("EIO during get_super()", c.t);
-        ceph_abort("fatal error");
       })
     ).si_then([c, root](auto&& super) {
       assert(super);

diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_accessor.h b/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_accessor.h
index 1a03036d3c3ed8930f21cb10d1965e5e9f544f0c..e4054e4fc0dfefd31e3d7c9e916e5c2e19f11d1d 100644 (file)
--- a/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_accessor.h
+++ b/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_accessor.h
@@ -523,12 +523,11 @@ class NodeExtentAccessorT {
     return c.nm.alloc_extent(c.t, hint, alloc_size
     ).handle_error_interruptible(
       eagain_iertr::pass_further{},
-      crimson::ct_error::input_output_error::handle(
+      crimson::ct_error::input_output_error::assert_failure(
           [FNAME, c, alloc_size, l_to_discard = extent->get_laddr()] {
         SUBERRORT(seastore_onode,
             "EIO during allocate -- node_size={}, to_discard={:x}",
             c.t, alloc_size, l_to_discard);
-        ceph_abort("fatal error");
       })
     ).si_then([this, c, FNAME] (auto fresh_extent) {
       SUBDEBUGT(seastore_onode,
@@ -552,21 +551,19 @@ class NodeExtentAccessorT {
       return c.nm.retire_extent(c.t, to_discard
       ).handle_error_interruptible(
         eagain_iertr::pass_further{},
-        crimson::ct_error::input_output_error::handle(
+        crimson::ct_error::input_output_error::assert_failure(
             [FNAME, c, l_to_discard = to_discard->get_laddr(),
              l_fresh = fresh_extent->get_laddr()] {
           SUBERRORT(seastore_onode,
               "EIO during retire -- to_disgard={:x}, fresh={:x}",
               c.t, l_to_discard, l_fresh);
-          ceph_abort("fatal error");
         }),
-        crimson::ct_error::enoent::handle(
+        crimson::ct_error::enoent::assert_failure(
             [FNAME, c, l_to_discard = to_discard->get_laddr(),
              l_fresh = fresh_extent->get_laddr()] {
           SUBERRORT(seastore_onode,
               "ENOENT during retire -- to_disgard={:x}, fresh={:x}",
               c.t, l_to_discard, l_fresh);
-          ceph_abort("fatal error");
         })
       );
     }).si_then([this, c] {
@@ -583,15 +580,13 @@ class NodeExtentAccessorT {
     return c.nm.retire_extent(c.t, std::move(extent)
     ).handle_error_interruptible(
       eagain_iertr::pass_further{},
-      crimson::ct_error::input_output_error::handle(
+      crimson::ct_error::input_output_error::assert_failure(
           [FNAME, c, addr] {
         SUBERRORT(seastore_onode, "EIO -- addr={:x}", c.t, addr);
-        ceph_abort("fatal error");
       }),
-      crimson::ct_error::enoent::handle(
+      crimson::ct_error::enoent::assert_failure(
           [FNAME, c, addr] {
         SUBERRORT(seastore_onode, "ENOENT -- addr={:x}", c.t, addr);
-        ceph_abort("fatal error");
       })
 #ifndef NDEBUG
     ).si_then([c] {

diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/node_layout.h b/src/crimson/os/seastore/onode_manager/staged-fltree/node_layout.h
index 783a0c6cc60c5ba032d89184b633c44cc1f54114..70db76be75d8f55ffb7a3daa94ba37717d5e29f0 100644 (file)
--- a/src/crimson/os/seastore/onode_manager/staged-fltree/node_layout.h
+++ b/src/crimson/os/seastore/onode_manager/staged-fltree/node_layout.h
@@ -78,12 +78,11 @@ class NodeLayoutT final : public InternalNodeImpl, public LeafNodeImpl {
     return c.nm.alloc_extent(c.t, hint, extent_size
     ).handle_error_interruptible(
       eagain_iertr::pass_further{},
-      crimson::ct_error::input_output_error::handle(
+      crimson::ct_error::input_output_error::assert_failure(
           [FNAME, c, extent_size, is_level_tail, level] {
         SUBERRORT(seastore_onode,
             "EIO -- extent_size={}, is_level_tail={}, level={}",
             c.t, extent_size, is_level_tail, level);
-        ceph_abort("fatal error");
       })
     ).si_then([is_level_tail, level](auto extent) {
       assert(extent);

diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/tree_utils.h b/src/crimson/os/seastore/onode_manager/staged-fltree/tree_utils.h
index 3ad3564a6fd58f10fa89c8f5da2ca46e7013d8a8..5c489daee3c245f679e1c2bac88ad68af2e35a18 100644 (file)
--- a/src/crimson/os/seastore/onode_manager/staged-fltree/tree_utils.h
+++ b/src/crimson/os/seastore/onode_manager/staged-fltree/tree_utils.h
@@ -327,9 +327,7 @@ class TreeBuilder {
       return eagain_iertr::make_ready_future<BtreeCursor>(cursor);
 #endif
     }).handle_error_interruptible(
-      [] (const crimson::ct_error::value_too_large& e) {
-        ceph_abort("impossible path");
-      },
+      crimson::ct_error::value_too_large::assert_failure{"impossible path"},
       crimson::ct_error::pass_further_all{}
     );
   }

diff --git a/src/crimson/os/seastore/seastore.cc b/src/crimson/os/seastore/seastore.cc
index a8dba42b34af5880b1f217752c47fb807561fe9b..50e7eb1d4ffb39e01eb1deaafa4657bf8798caba 100644 (file)
--- a/src/crimson/os/seastore/seastore.cc
+++ b/src/crimson/os/seastore/seastore.cc
@@ -951,10 +951,10 @@ SeaStore::Shard::get_attr(
           onode.get_metadata_hint(device->get_block_size())),
         name);
     }
-  ).handle_error(crimson::ct_error::input_output_error::handle([FNAME] {
-    ERROR("EIO when getting attrs");
-    abort();
-  }), crimson::ct_error::pass_further_all{});
+  ).handle_error(
+    crimson::ct_error::input_output_error::assert_failure{
+      "EIO when getting attrs"},
+    crimson::ct_error::pass_further_all{});
 }
 
 SeaStore::Shard::get_attrs_ertr::future<SeaStore::Shard::attrs_t>
@@ -994,10 +994,10 @@ SeaStore::Shard::get_attrs(
         return seastar::make_ready_future<omap_values_t>(std::move(attrs));
       });
     }
-  ).handle_error(crimson::ct_error::input_output_error::handle([FNAME] {
-    ERROR("EIO when getting attrs");
-    abort();
-  }), crimson::ct_error::pass_further_all{});
+  ).handle_error(
+    crimson::ct_error::input_output_error::assert_failure{
+      "EIO when getting attrs"},
+    crimson::ct_error::pass_further_all{});
 }
 
 seastar::future<struct stat> SeaStore::Shard::stat(

diff --git a/src/crimson/os/seastore/seastore.h b/src/crimson/os/seastore/seastore.h
index 75dbaf54f35b5a7f43b164e0a0f04a1ad9e41dd2..3de8a812e1291c70b76d34aa7e3579bd102abe0e 100644 (file)
--- a/src/crimson/os/seastore/seastore.h
+++ b/src/crimson/os/seastore/seastore.h
@@ -257,6 +257,7 @@ public:
          }).handle_error(
            crimson::ct_error::all_same_way([&ctx](auto e) {
              on_error(ctx.ext_transaction);
+             return seastar::now();
            })
          );
        }).then([this, op_type, &ctx] {

diff --git a/src/crimson/os/seastore/transaction_manager.cc b/src/crimson/os/seastore/transaction_manager.cc
index ed52b022f72b97afb6433289473607a4f3ab5699..0fad3bc99cd779799ff3c5be0cb221f75647872f 100644 (file)
--- a/src/crimson/os/seastore/transaction_manager.cc
+++ b/src/crimson/os/seastore/transaction_manager.cc
@@ -157,10 +157,7 @@ TransactionManager::mount_ertr::future<> TransactionManager::mount()
     INFO("completed");
   }).handle_error(
     mount_ertr::pass_further{},
-    crimson::ct_error::all_same_way([] {
-      ceph_assert(0 == "unhandled error");
-      return mount_ertr::now();
-    })
+    crimson::ct_error::assert_all{"unhandled error"}
   );
 }
 
@@ -195,9 +192,7 @@ TransactionManager::ref_ret TransactionManager::inc_ref(
     return result.refcount;
   }).handle_error_interruptible(
     ref_iertr::pass_further{},
-    ct_error::all_same_way([](auto e) {
-      ceph_assert(0 == "unhandled error, TODO");
-    }));
+    ct_error::assert_all{"unhandled error, TODO"});
 }
 
 TransactionManager::ref_ret TransactionManager::inc_ref(
@@ -457,9 +452,7 @@ TransactionManager::do_submit_transaction(
       });
     }).handle_error(
       submit_transaction_iertr::pass_further{},
-      crimson::ct_error::all_same_way([](auto e) {
-       ceph_assert(0 == "Hit error submitting to journal");
-      })
+      crimson::ct_error::assert_all{"Hit error submitting to journal"}
     );
   });
 }

diff --git a/src/crimson/osd/heartbeat.cc b/src/crimson/osd/heartbeat.cc
index 49e3562494791d5d4f1674e9c80e31a2d55990cb..03986952b4f24c6b035c27c908d13bd6d9a1f3e7 100644 (file)
--- a/src/crimson/osd/heartbeat.cc
+++ b/src/crimson/osd/heartbeat.cc
@@ -78,10 +78,9 @@ Heartbeat::start_messenger(crimson::net::Messenger& msgr,
 {
   return msgr.bind(addrs).safe_then([this, &msgr]() mutable {
     return msgr.start({this});
-  }, crimson::net::Messenger::bind_ertr::all_same_way(
+  }, crimson::net::Messenger::bind_ertr::assert_all_func(
       [addrs] (const std::error_code& e) {
     logger().error("heartbeat messenger bind({}): {}", addrs, e);
-    ceph_abort();
   }));
 }
 

diff --git a/src/crimson/osd/osd.cc b/src/crimson/osd/osd.cc
index 459943c3b607ae6520f9ac9b3c2a3236142cfbd6..6b43abca51268aa854dc2ff77aefc3ed53b89476 100644 (file)
--- a/src/crimson/osd/osd.cc
+++ b/src/crimson/osd/osd.cc
@@ -199,19 +199,17 @@ seastar::future<> OSD::mkfs(
   LOG_PREFIX(OSD::mkfs);
   return store.start().then([&store, FNAME, osd_uuid] {
     return store.mkfs(osd_uuid).handle_error(
-      crimson::stateful_ec::handle([FNAME] (const auto& ec) {
+      crimson::stateful_ec::assert_failure([FNAME] (const auto& ec) {
         ERROR("error creating empty object store in {}: ({}) {}",
              local_conf().get_val<std::string>("osd_data"),
              ec.value(), ec.message());
-        std::exit(EXIT_FAILURE);
       }));
   }).then([&store, FNAME] {
     return store.mount().handle_error(
-      crimson::stateful_ec::handle([FNAME](const auto& ec) {
+      crimson::stateful_ec::assert_failure([FNAME](const auto& ec) {
         ERROR("error mounting object store in {}: ({}) {}",
              local_conf().get_val<std::string>("osd_data"),
              ec.value(), ec.message());
-        std::exit(EXIT_FAILURE);
       }));
   }).then([&store] {
     return open_or_create_meta_coll(store);
@@ -411,11 +409,10 @@ seastar::future<> OSD::start()
        whoami, get_shard_services(),
        *monc, *hb_front_msgr, *hb_back_msgr});
     return store.mount().handle_error(
-      crimson::stateful_ec::handle([FNAME] (const auto& ec) {
+      crimson::stateful_ec::assert_failure([FNAME] (const auto& ec) {
         ERROR("error mounting object store in {}: ({}) {}",
              local_conf().get_val<std::string>("osd_data"),
              ec.value(), ec.message());
-        std::exit(EXIT_FAILURE);
       }));
   }).then([this] {
     return open_meta_coll();
@@ -470,18 +467,16 @@ seastar::future<> OSD::start()
       cluster_msgr->bind(pick_addresses(CEPH_PICK_ADDRESS_CLUSTER))
         .safe_then([this, dispatchers]() mutable {
          return cluster_msgr->start(dispatchers);
-        }, crimson::net::Messenger::bind_ertr::all_same_way(
+        }, crimson::net::Messenger::bind_ertr::assert_all_func(
             [FNAME] (const std::error_code& e) {
           ERROR("cluster messenger bind(): {}", e);
-          ceph_abort();
         })),
       public_msgr->bind(pick_addresses(CEPH_PICK_ADDRESS_PUBLIC))
         .safe_then([this, dispatchers]() mutable {
          return public_msgr->start(dispatchers);
-        }, crimson::net::Messenger::bind_ertr::all_same_way(
+        }, crimson::net::Messenger::bind_ertr::assert_all_func(
             [FNAME] (const std::error_code& e) {
           ERROR("public messenger bind(): {}", e);
-          ceph_abort();
         })));
   }).then_unpack([this] {
     return seastar::when_all_succeed(monc->start(),

diff --git a/src/crimson/osd/osd_meta.cc b/src/crimson/osd/osd_meta.cc
index 45a98bfc3af625a9f6ac2d769231be5edb4bfa1e..d959ac140299ded54d3d14cf978d8a89aaf14f55 100644 (file)
--- a/src/crimson/osd/osd_meta.cc
+++ b/src/crimson/osd/osd_meta.cc
@@ -45,7 +45,7 @@ seastar::future<bufferlist> OSDMeta::load_map(epoch_t e)
   return store.read(coll,
                     osdmap_oid(e), 0, 0,
                     CEPH_OSD_OP_FLAG_FADVISE_WILLNEED).handle_error(
-    read_errorator::all_same_way([e] {
+    read_errorator::assert_all_func([e](const auto&) {
       ceph_abort_msg(fmt::format("{} read gave enoent on {}",
                                  __func__, osdmap_oid(e)));
     }));
@@ -97,7 +97,7 @@ OSDMeta::load_final_pool_info(int64_t pool) {
       std::make_tuple(std::move(pi),
                      std::move(name),
                      std::move(ec_profile)));
-  },read_errorator::all_same_way([pool] {
+  },read_errorator::assert_all_func([pool](const auto&) {
     throw std::runtime_error(fmt::format("read gave enoent on {}",
                                          final_pool_info_oid(pool)));
   }));

diff --git a/src/crimson/osd/osd_operations/scrub_events.cc b/src/crimson/osd/osd_operations/scrub_events.cc
index 0ee6d6809f64d3f55abfd49dbb69cfaae6e7adac..2640456bf95418f51e905dd12627d9a9068e4a5b 100644 (file)
--- a/src/crimson/osd/osd_operations/scrub_events.cc
+++ b/src/crimson/osd/osd_operations/scrub_events.cc
@@ -208,6 +208,7 @@ ScrubScan::ifut<> ScrubScan::scan_object(
     ct_error::all_same_way([FNAME, &pg, &obj, &entry](auto e) {
       DEBUGDPP("obj: {} stat error", pg, obj);
       entry.stat_error = true;
+      return seastar::now();
     })
   ).then_interruptible([FNAME, this, &pg, &obj] {
     if (deep) {
@@ -270,6 +271,7 @@ ScrubScan::ifut<> ScrubScan::deep_scan_object(
          ct_error::all_same_way([&progress, &entry](auto e) {
            entry.read_error = true;
            progress.offset = std::nullopt;
+           return seastar::now();
          })
        ).then([] {
          return interruptor::make_interruptible(
@@ -285,9 +287,10 @@ ScrubScan::ifut<> ScrubScan::deep_scan_object(
        ).safe_then([&progress](auto bl) {
          progress.omap_hash << bl;
        }).handle_error(
-         ct_error::enodata::handle([] {}),
+         ct_error::enodata::handle([] { return seastar::now(); }),
          ct_error::all_same_way([&entry](auto e) {
            entry.read_error = true;
+           return seastar::now();
          })
        ).then([&progress] {
          progress.header_done = true;
@@ -344,6 +347,7 @@ ScrubScan::ifut<> ScrubScan::deep_scan_object(
                     pg, *this, obj, progress, e);
            progress.keys_done = true;
            entry.read_error = true;
+           return seastar::now();
          })
        ).then([] {
          return interruptor::make_interruptible(

diff --git a/src/crimson/osd/replicated_recovery_backend.cc b/src/crimson/osd/replicated_recovery_backend.cc
index 5a29b1d3353b22bf6095bb883d00f0bec430dc14..4b4db79af49f69b587d1c31791663ec05e2fbf4d 100644 (file)
--- a/src/crimson/osd/replicated_recovery_backend.cc
+++ b/src/crimson/osd/replicated_recovery_backend.cc
@@ -45,6 +45,7 @@ ReplicatedRecoveryBackend::recover_object(
       // TODO: may need eio handling?
       logger().error("recover_object saw error code {}, ignoring object {}",
                      code, soid);
+      return seastar::now();
     }));
   });
 }

diff --git a/src/crimson/tools/perf_crimson_msgr.cc b/src/crimson/tools/perf_crimson_msgr.cc
index aa5753442e28e44ff32d093226fc02feb8b0ddf7..0bded8c2ea79cee7c4a453c8c6929660aa70e7b5 100644 (file)
--- a/src/crimson/tools/perf_crimson_msgr.cc
+++ b/src/crimson/tools/perf_crimson_msgr.cc
@@ -257,11 +257,10 @@ static seastar::future<> run(
           return server.msgr->bind(entity_addrvec_t{addr}
           ).safe_then([&server] {
             return server.msgr->start({&server});
-          }, crimson::net::Messenger::bind_ertr::all_same_way(
+          }, crimson::net::Messenger::bind_ertr::assert_all_func(
               [addr] (const std::error_code& e) {
             logger().error("Server: "
                            "there is another instance running at {}", addr);
-            ceph_abort();
           }));
         });
       }

diff --git a/src/crimson/tools/store_nbd/fs_driver.cc b/src/crimson/tools/store_nbd/fs_driver.cc
index 18f83676645ebd7019946f5039e58585fe769c90..e0c7a5c8f0789da759c6bf5c7ef696e937a76990 100644 (file)
--- a/src/crimson/tools/store_nbd/fs_driver.cc
+++ b/src/crimson/tools/store_nbd/fs_driver.cc
@@ -185,12 +185,11 @@ seastar::future<> FSDriver::mkfs()
     uuid_d uuid;
     uuid.generate_random();
     return fs->mkfs(uuid).handle_error(
-      crimson::stateful_ec::handle([] (const auto& ec) {
+      crimson::stateful_ec::assert_failure([] (const auto& ec) {
         crimson::get_logger(ceph_subsys_test)
           .error("error creating empty object store in {}: ({}) {}",
           crimson::common::local_conf().get_val<std::string>("osd_data"),
           ec.value(), ec.message());
-        std::exit(EXIT_FAILURE);
       }));
   }).then([this] {
     return fs->stop();
@@ -199,7 +198,7 @@ seastar::future<> FSDriver::mkfs()
   }).then([this] {
     return fs->mount(
     ).handle_error(
-      crimson::stateful_ec::handle([] (const auto& ec) {
+      crimson::stateful_ec::assert_failure([] (const auto& ec) {
         crimson::get_logger(
          ceph_subsys_test
        ).error(
@@ -207,7 +206,6 @@ seastar::future<> FSDriver::mkfs()
          crimson::common::local_conf().get_val<std::string>("osd_data"),
          ec.value(),
          ec.message());
-       std::exit(EXIT_FAILURE);
       }));
   }).then([this] {
     return seastar::do_for_each(
@@ -241,7 +239,7 @@ seastar::future<> FSDriver::mount()
   }).then([this] {
     return fs->mount(
     ).handle_error(
-      crimson::stateful_ec::handle([] (const auto& ec) {
+      crimson::stateful_ec::assert_failure([] (const auto& ec) {
         crimson::get_logger(
          ceph_subsys_test
        ).error(
@@ -249,7 +247,6 @@ seastar::future<> FSDriver::mount()
          crimson::common::local_conf().get_val<std::string>("osd_data"),
          ec.value(),
          ec.message());
-        std::exit(EXIT_FAILURE);
       }));
   }).then([this] {
     return seastar::do_for_each(

diff --git a/src/osd/PGLog.cc b/src/osd/PGLog.cc
index 90f35097de63f9feb97f4ccee11ee10364f12c70..e11eda5162f05b56c6ac5e3590c0f39044a34cb1 100644 (file)
--- a/src/osd/PGLog.cc
+++ b/src/osd/PGLog.cc
@@ -1279,7 +1279,7 @@ seastar::future<> PGLog::rebuild_missing_set_with_deletes_crimson(
          log_entry.is_delete());
        return seastar::now();
       }),
-      crimson::ct_error::enodata::handle([] { ceph_abort("unexpected enodata"); })
+      crimson::ct_error::enodata::assert_failure{"unexpected enodata"}
       ).then([] {
        return seastar::stop_iteration::no;
       });

diff --git a/src/test/crimson/seastore/onode_tree/test_staged_fltree.cc b/src/test/crimson/seastore/onode_tree/test_staged_fltree.cc
index 5521d52799d6e39666ccbe43b3a49e586294c16d..79668ed9333ffd54b4bfb690e1ccb0bb1998fe4f 100644 (file)
--- a/src/test/crimson/seastore/onode_tree/test_staged_fltree.cc
+++ b/src/test/crimson/seastore/onode_tree/test_staged_fltree.cc
@@ -209,9 +209,7 @@ struct b_dummy_tree_test_t : public seastar_test_suite_t {
       new UnboundedBtree(NodeExtentManager::create_dummy(IS_DUMMY_SYNC))
     );
     return INTR(tree->mkfs, *ref_t).handle_error(
-      crimson::ct_error::all_same_way([] {
-        ASSERT_FALSE("Unable to mkfs");
-      })
+      crimson::ct_error::assert_all{"Unable to mkfs"}
     );
   }
 

diff --git a/src/test/crimson/seastore/test_btree_lba_manager.cc b/src/test/crimson/seastore/test_btree_lba_manager.cc
index 977b8c386506946cc23acbdf0743be9ba2f5cefa..8cdadd097a3c552cf4a33abd3fa163f263cbf5f8 100644 (file)
--- a/src/test/crimson/seastore/test_btree_lba_manager.cc
+++ b/src/test/crimson/seastore/test_btree_lba_manager.cc
@@ -176,9 +176,7 @@ struct btree_test_base :
          });
        });
     }).handle_error(
-      crimson::ct_error::all_same_way([] {
-       ceph_assert(0 == "error");
-      })
+      crimson::ct_error::assert_all{"error"}
     );
   }
 
@@ -197,9 +195,7 @@ struct btree_test_base :
       epm.reset();
       cache.reset();
     }).handle_error(
-      crimson::ct_error::all_same_way([] {
-       ASSERT_FALSE("Unable to close");
-      })
+      crimson::ct_error::assert_all{"Unable to close"}
     );
   }
 };

diff --git a/src/test/crimson/seastore/test_seastore.cc b/src/test/crimson/seastore/test_seastore.cc
index e0d01bc2b4baa661b6a1436713bead704868cd7b..1a127214e8f0c98ec968876ab79a176d025a1aa5 100644 (file)
--- a/src/test/crimson/seastore/test_seastore.cc
+++ b/src/test/crimson/seastore/test_seastore.cc
@@ -394,17 +394,18 @@ struct seastore_test_t :
     SeaStoreShard::attrs_t get_attrs(
       SeaStoreShard &sharded_seastore) {
       return sharded_seastore.get_attrs(coll, oid)
-                    .handle_error(SeaStoreShard::get_attrs_ertr::discard_all{})
-                    .get();
+       .handle_error(
+         SeaStoreShard::get_attrs_ertr::assert_all{"unexpected error"})
+       .get();
     }
 
     ceph::bufferlist get_attr(
       SeaStoreShard& sharded_seastore,
       std::string_view name) {
       return sharded_seastore.get_attr(coll, oid, name)
-                     .handle_error(
-                       SeaStoreShard::get_attr_errorator::discard_all{})
-                     .get();
+       .handle_error(
+         SeaStoreShard::get_attr_errorator::assert_all{"unexpected error"})
+       .get();
     }
 
     void check_omap_key(

diff --git a/src/test/crimson/seastore/test_seastore_cache.cc b/src/test/crimson/seastore/test_seastore_cache.cc
index 518e6428b2adc4e6a20e8834730f49efaec3109a..87918dbd02e26e1dac5fe39f34dc7f98693d3105 100644 (file)
--- a/src/test/crimson/seastore/test_seastore_cache.cc
+++ b/src/test/crimson/seastore/test_seastore_cache.cc
@@ -81,9 +81,7 @@ struct cache_test_t : public seastar_test_suite_t {
        cache->complete_commit(*t, prev, seq /* TODO */);
         return prev;
       },
-      crimson::ct_error::all_same_way([](auto e) {
-       ASSERT_FALSE("failed to submit");
-      })
+      crimson::ct_error::assert_all{"failed to submit"}
      );
   }
 
@@ -125,9 +123,7 @@ struct cache_test_t : public seastar_test_suite_t {
         });
       });
     }).handle_error(
-      crimson::ct_error::all_same_way([](auto e) {
-        ASSERT_FALSE("failed to submit");
-      })
+      crimson::ct_error::assert_all{"failed to submit"}
     );
   }
 

diff --git a/src/test/crimson/seastore/test_seastore_journal.cc b/src/test/crimson/seastore/test_seastore_journal.cc
index ddd894349d21e6e88ad3dd16fd1e2b0bc371e704..fa9b7b1b809283107ccbd5ae5127f15d772d177c 100644 (file)
--- a/src/test/crimson/seastore/test_seastore_journal.cc
+++ b/src/test/crimson/seastore/test_seastore_journal.cc
@@ -158,9 +158,7 @@ struct journal_test_t : seastar_test_suite_t, SegmentProvider, JournalTrimmer {
     }).safe_then([this](auto) {
       dummy_tail = journal_seq_t{0,
         paddr_t::make_seg_paddr(segment_id_t(segment_manager->get_device_id(), 0), 0)};
-    }, crimson::ct_error::all_same_way([] {
-      ASSERT_FALSE("Unable to mount");
-    }));
+    }, crimson::ct_error::assert_all{"Unable to mount"});
   }
 
   seastar::future<> tear_down_fut() final {
@@ -170,9 +168,7 @@ struct journal_test_t : seastar_test_suite_t, SegmentProvider, JournalTrimmer {
       sms.reset();
       journal.reset();
     }).handle_error(
-      crimson::ct_error::all_same_way([](auto e) {
-        ASSERT_FALSE("Unable to close");
-      })
+      crimson::ct_error::assert_all{"Unable to close"}
     );
   }
 

diff --git a/src/test/crimson/test_alien_echo.cc b/src/test/crimson/test_alien_echo.cc
index f6b23305ce5c1a89e1d3d6bff1bb2e896ffe11c3..b48f3a748869cc0050d0d47b23a2a8502f0be69d 100644 (file)
--- a/src/test/crimson/test_alien_echo.cc
+++ b/src/test/crimson/test_alien_echo.cc
@@ -179,9 +179,8 @@ seastar_echo(const entity_addr_t addr, echo_role role, unsigned count)
       return server.msgr->bind(entity_addrvec_t{addr}
       ).safe_then([&server] {
         return server.msgr->start({&server.dispatcher});
-      }, crimson::net::Messenger::bind_ertr::all_same_way([](auto& e) {
-        ceph_abort_msg("bind failed");
-      })).then([&dispatcher=server.dispatcher, count] {
+      }, crimson::net::Messenger::bind_ertr::assert_all{"bind failed"}
+      ).then([&dispatcher=server.dispatcher, count] {
         return dispatcher.on_reply.wait([&dispatcher, count] {
           return dispatcher.count >= count;
         });

diff --git a/src/test/crimson/test_interruptible_future.cc b/src/test/crimson/test_interruptible_future.cc
index bb938de24e77fd66ca076527b8b76ea61b3701c0..3be558b4df65ba557df2132af23dc75e474f9244 100644 (file)
--- a/src/test/crimson/test_interruptible_future.cc
+++ b/src/test/crimson/test_interruptible_future.cc
@@ -64,6 +64,7 @@ TEST_F(seastar_test_suite_t, basic)
          return seastar::now();
        }, errorator<ct_error::enoent>::all_same_way([] {
          ceph_assert(interruptible::interrupt_cond<TestInterruptCondition>.interrupt_cond);
+         return seastar::now();
          })
        );
       }, [](std::exception_ptr) {}, false).get0();
@@ -146,6 +147,7 @@ TEST_F(seastar_test_suite_t, loops)
                return seastar::now();
              }, errorator<ct_error::enoent>::all_same_way([] {
                ceph_assert(interruptible::interrupt_cond<TestInterruptCondition>.interrupt_cond);
+               return seastar::now();
              }));
            });
          });
@@ -167,6 +169,7 @@ TEST_F(seastar_test_suite_t, loops)
                return seastar::now();
              }, errorator<ct_error::enoent>::all_same_way([] {
                ceph_assert(interruptible::interrupt_cond<TestInterruptCondition>.interrupt_cond);
+               return seastar::now();
              }));
            });
          });

diff --git a/src/test/crimson/test_messenger.cc b/src/test/crimson/test_messenger.cc
index 75bbcd7a647685b77bd0efd1c4128dc3a422b07e..dc23447a7fff864c41add53f0a7498a1bbbed4bd 100644 (file)
--- a/src/test/crimson/test_messenger.cc
+++ b/src/test/crimson/test_messenger.cc
@@ -153,11 +153,10 @@ static seastar::future<> test_echo(unsigned rounds,
         msgr->set_auth_server(&dummy_auth);
         return msgr->bind(entity_addrvec_t{addr}).safe_then([this] {
           return msgr->start({this});
-        }, crimson::net::Messenger::bind_ertr::all_same_way(
+        }, crimson::net::Messenger::bind_ertr::assert_all_func(
             [addr] (const std::error_code& e) {
           logger().error("test_echo(): "
                          "there is another instance running at {}", addr);
-          ceph_abort();
         }));
       }
       seastar::future<> shutdown() {
@@ -422,11 +421,10 @@ seastar::future<> test_preemptive_shutdown() {
         msgr->set_auth_server(&dummy_auth);
         return msgr->bind(entity_addrvec_t{addr}).safe_then([this] {
           return msgr->start({this});
-        }, crimson::net::Messenger::bind_ertr::all_same_way(
+        }, crimson::net::Messenger::bind_ertr::assert_all_func(
             [addr] (const std::error_code& e) {
           logger().error("test_preemptive_shutdown(): "
                          "there is another instance running at {}", addr);
-          ceph_abort();
         }));
       }
       entity_addr_t get_addr() const {
@@ -1044,10 +1042,10 @@ class FailoverSuite : public Dispatcher {
     test_msgr->set_interceptor(&interceptor);
     return test_msgr->bind(entity_addrvec_t{test_addr}).safe_then([this] {
       return test_msgr->start({this});
-    }, Messenger::bind_ertr::all_same_way([test_addr] (const std::error_code& e) {
+    }, Messenger::bind_ertr::assert_all_func(
+      [test_addr] (const std::error_code& e) {
       logger().error("FailoverSuite: "
                      "there is another instance running at {}", test_addr);
-      ceph_abort();
     }));
   }
 
@@ -1607,10 +1605,10 @@ class FailoverSuitePeer : public Dispatcher {
     peer_msgr->set_auth_server(&dummy_auth);
     return peer_msgr->bind(entity_addrvec_t{test_peer_addr}).safe_then([this] {
       return peer_msgr->start({this});
-    }, Messenger::bind_ertr::all_same_way([test_peer_addr] (const std::error_code& e) {
+    }, Messenger::bind_ertr::assert_all_func(
+      [test_peer_addr] (const std::error_code& e) {
       logger().error("FailoverSuitePeer: "
                      "there is another instance running at {}", test_peer_addr);
-      ceph_abort();
     }));
   }
 
@@ -1811,10 +1809,10 @@ class FailoverTestPeer : public Dispatcher {
     cmd_msgr->set_auth_server(&dummy_auth);
     return cmd_msgr->bind(entity_addrvec_t{cmd_peer_addr}).safe_then([this] {
       return cmd_msgr->start({this});
-    }, Messenger::bind_ertr::all_same_way([cmd_peer_addr] (const std::error_code& e) {
+    }, Messenger::bind_ertr::assert_all_func(
+      [cmd_peer_addr] (const std::error_code& e) {
       logger().error("FailoverTestPeer: "
                      "there is another instance running at {}", cmd_peer_addr);
-      ceph_abort();
     }));
   }
 

diff --git a/src/test/crimson/test_messenger_thrash.cc b/src/test/crimson/test_messenger_thrash.cc
index 28efb60fd5cc4467d26184cab0b7e505c4423f6e..4146ec45b66343e92d92f635b3c7ac7f311586c9 100644 (file)
--- a/src/test/crimson/test_messenger_thrash.cc
+++ b/src/test/crimson/test_messenger_thrash.cc
@@ -365,12 +365,11 @@ class SyntheticWorkload {
      return msgr->bind(entity_addrvec_t{addr}).safe_then(
          [this, msgr] {
        return msgr->start({&dispatcher});
-     }, crimson::net::Messenger::bind_ertr::all_same_way(
+     }, crimson::net::Messenger::bind_ertr::assert_all_func(
          [addr] (const std::error_code& e) {
        logger().error("{} test_messenger_thrash(): "
                       "there is another instance running at {}",
                        __func__, addr);
-       ceph_abort();
      }));
    }
 

diff --git a/src/test/crimson/test_socket.cc b/src/test/crimson/test_socket.cc
index 99c8aee84f7702eed1171e2747bdfd59d1ad89ac..fb9d60993ed2d49861363b74441390f5eaf79a7c 100644 (file)
--- a/src/test/crimson/test_socket.cc
+++ b/src/test/crimson/test_socket.cc
@@ -99,11 +99,10 @@ future<> test_bind_same(bool is_fixed_cpu) {
           return pss2->shutdown_destroy();
         });
       });
-    }, listen_ertr::all_same_way(
+    }, listen_ertr::assert_all_func(
         [saddr](const std::error_code& e) {
       logger().error("test_bind_same(): there is another instance running at {}",
                      saddr);
-      ceph_abort();
     })).then([pss1] {
       return pss1->shutdown_destroy();
     }).handle_exception([](auto eptr) {
@@ -129,11 +128,10 @@ future<> test_accept(bool is_fixed_cpu) {
           ).finally([cleanup = std::move(socket)] {});
         });
       });
-    }, listen_ertr::all_same_way(
+    }, listen_ertr::assert_all_func(
         [saddr](const std::error_code& e) {
       logger().error("test_accept(): there is another instance running at {}",
                      saddr);
-      ceph_abort();
     })).then([saddr] {
       return seastar::when_all(
         socket_connect(saddr).then([](auto socket) {
@@ -184,10 +182,10 @@ class SocketFactory {
         psf->pss = pss;
         return pss->listen(saddr
         ).safe_then([] {
-        }, listen_ertr::all_same_way([saddr](const std::error_code& e) {
+        }, listen_ertr::assert_all_func(
+         [saddr](const std::error_code& e) {
           logger().error("dispatch_sockets(): there is another instance running at {}",
                          saddr);
-          ceph_abort();
         }));
       });
     }).then([psf, saddr] {