osd: s/assert/ceph_assert/g'

Matan-B · Matan-B · commit f0028be0ec56 · 2025-05-20T08:01:17.000Z
Now that we fallback to RelDebWithInfo [1], C asserts are not compiled in. Replace some of the existing asserts with ceph_assserts instead. [1] ceph#61637 Fixes: https://tracker.ceph.com/issues/71360 Signed-off-by: Matan Breizman <mbreizma@redhat.com>
diff --git a/src/osd/ECBackend.cc b/src/osd/ECBackend.cc
@@ -1432,7 +1432,7 @@ struct ECClassicalOp : ECCommon::RMWPipeline::Op {
     shard_id_map<ObjectStore::Transaction> *transactions,
     DoutPrefixProvider *dpp,
     const OSDMapRef &osdmap) final {
-    assert(t);
+    ceph_assert(t);
     ECTransaction::generate_transactions(
       t.get(),
       plan,
diff --git a/src/osd/ECBackendL.cc b/src/osd/ECBackendL.cc
@@ -1444,7 +1444,7 @@ struct ECClassicalOp : ECCommonL::RMWPipeline::Op {
       DoutPrefixProvider *dpp,
       const ceph_release_t require_osd_release) final
   {
-    assert(t);
+    ceph_assert(t);
     ECTransactionL::generate_transactions(
       t.get(),
       plan,
diff --git a/src/osd/ECUtilL.h b/src/osd/ECUtilL.h
@@ -172,7 +172,7 @@ class stripe_info_t {
   }
   std::pair<uint64_t, uint64_t> offset_length_to_data_chunk_indices(
     uint64_t off, uint64_t len) const {
-    assert(chunk_size > 0);
+    ceph_assert(chunk_size > 0);
     const auto first_chunk_idx = (off / chunk_size);
     const auto last_chunk_idx = (chunk_size - 1 + off + len) / chunk_size;
     return {first_chunk_idx, last_chunk_idx};
@@ -182,7 +182,7 @@ class stripe_info_t {
     if (len == 0) {
       return true;
     }
-    assert(chunk_size > 0);
+    ceph_assert(chunk_size > 0);
     const auto first_stripe_idx = off / stripe_width;
     const auto last_inc_stripe_idx = (off + len - 1) / stripe_width;
     return first_stripe_idx == last_inc_stripe_idx;
diff --git a/src/osd/OSD.cc b/src/osd/OSD.cc
@@ -1951,7 +1951,7 @@ void OSDService::set_ready_to_merge_source(PG *pg, eversion_t version)
   std::lock_guard l(merge_lock);
   dout(10) << __func__ << " " << pg->pg_id << dendl;
   ready_to_merge_source[pg->pg_id.pgid] = version;
-  assert(not_ready_to_merge_source.count(pg->pg_id.pgid) == 0);
+  ceph_assert(not_ready_to_merge_source.count(pg->pg_id.pgid) == 0);
   _send_ready_to_merge();
 }
 
@@ -1966,7 +1966,7 @@ void OSDService::set_ready_to_merge_target(PG *pg,
 					 make_tuple(version,
 						    last_epoch_started,
 						    last_epoch_clean)));
-  assert(not_ready_to_merge_target.count(pg->pg_id.pgid) == 0);
+  ceph_assert(not_ready_to_merge_target.count(pg->pg_id.pgid) == 0);
   _send_ready_to_merge();
 }
 
@@ -1975,7 +1975,7 @@ void OSDService::set_not_ready_to_merge_source(pg_t source)
   std::lock_guard l(merge_lock);
   dout(10) << __func__ << " " << source << dendl;
   not_ready_to_merge_source.insert(source);
-  assert(ready_to_merge_source.count(source) == 0);
+  ceph_assert(ready_to_merge_source.count(source) == 0);
   _send_ready_to_merge();
 }
 
@@ -1984,7 +1984,7 @@ void OSDService::set_not_ready_to_merge_target(pg_t target, pg_t source)
   std::lock_guard l(merge_lock);
   dout(10) << __func__ << " " << target << " source " << source << dendl;
   not_ready_to_merge_target[target] = source;
-  assert(ready_to_merge_target.count(target) == 0);
+  ceph_assert(ready_to_merge_target.count(target) == 0);
   _send_ready_to_merge();
 }
 
@@ -4055,13 +4055,13 @@ int OSD::init()
 	for (auto shard : shards) {
 	  shard->prime_splits(osdmap, &new_children);
 	}
-	assert(new_children.empty());
+	ceph_assert(new_children.empty());
       }
       if (!merge_pgs.empty()) {
 	for (auto shard : shards) {
 	  shard->prime_merges(osdmap, &merge_pgs);
 	}
-	assert(merge_pgs.empty());
+	ceph_assert(merge_pgs.empty());
       }
     }
   }
@@ -5449,7 +5449,7 @@ void OSD::load_pgs()
     }
     {
       uint32_t shard_index = pgid.hash_to_shard(shards.size());
-      assert(NULL != shards[shard_index]);
+      ceph_assert(NULL != shards[shard_index]);
       store->set_collection_commit_queue(pg->coll, &(shards[shard_index]->context_queue));
     }
 
@@ -5518,7 +5518,7 @@ PGRef OSD::handle_pg_create_info(const OSDMapRef& osdmap,
 
   {
     uint32_t shard_index = pgid.hash_to_shard(shards.size());
-    assert(NULL != shards[shard_index]);
+    ceph_assert(NULL != shards[shard_index]);
     store->set_collection_commit_queue(pg->coll, &(shards[shard_index]->context_queue));
   }
 
@@ -5673,7 +5673,7 @@ void OSD::_add_heartbeat_peer(int p)
     pair<ConnectionRef,ConnectionRef> cons = service.get_con_osd_hb(p, get_osdmap_epoch());
     if (!cons.first)
       return;
-    assert(cons.second);
+    ceph_assert(cons.second);
 
     hi = &heartbeat_peers[p];
     hi->peer = p;
@@ -7943,7 +7943,7 @@ MPGStats* OSD::collect_pg_stats()
       per_pool_stats = false;
       break;
     } else {
-      assert(r >= 0);
+      ceph_assert(r >= 0);
       m->pool_stat[p] = st;
     }
   }
@@ -9365,7 +9365,7 @@ void OSD::split_pgs(
 
     {
       uint32_t shard_index = i->hash_to_shard(shards.size());
-      assert(NULL != shards[shard_index]);
+      ceph_assert(NULL != shards[shard_index]);
       store->set_collection_commit_queue(child->coll, &(shards[shard_index]->context_queue));
     }
 
diff --git a/src/osd/OSDMap.cc b/src/osd/OSDMap.cc
@@ -2905,7 +2905,7 @@ const std::vector<int> OSDMap::pgtemp_undo_primaryfirst(const pg_pool_t& pool,
       std::vector<int> result;
       int primaryshard = 0;
       int nonprimaryshard = pool.size - pool.nonprimary_shards.size();
-      assert(acting.size() == pool.size);
+      ceph_assert(acting.size() == pool.size);
       for (auto shard = 0; shard < pool.size; shard++) {
 	if (pool.is_nonprimary_shard(shard_id_t(shard))) {
 	  result.emplace_back(acting[nonprimaryshard++]);
@@ -7888,7 +7888,7 @@ void OSDMap::get_random_up_osds_by_subtree(int n,     // whoami
 float OSDMap::pool_raw_used_rate(int64_t poolid) const
 {
   const pg_pool_t *pool = get_pg_pool(poolid);
-  assert(pool != nullptr);
+  ceph_assert(pool != nullptr);
 
   switch (pool->get_type()) {
   case pg_pool_t::TYPE_REPLICATED:
diff --git a/src/osd/OSDMap.h b/src/osd/OSDMap.h
@@ -893,7 +893,7 @@ class OSDMap {
   }
 
   bool exists(int osd) const {
-    //assert(osd >= 0);
+    //ceph_assert(osd >= 0);
     return osd >= 0 && osd < max_osd && (osd_state[osd] & CEPH_OSD_EXISTS);
   }
 
diff --git a/src/osd/PGLog.cc b/src/osd/PGLog.cc
@@ -1178,7 +1178,7 @@ namespace {
           }).then([this] {
             if (info.pgid.is_no_shard()) {
               // replicated pool pg does not persist this key
-              assert(on_disk_rollback_info_trimmed_to == eversion_t());
+              ceph_assert(on_disk_rollback_info_trimmed_to == eversion_t());
               on_disk_rollback_info_trimmed_to = info.last_update;
             }
             log = PGLog::IndexedLog(
diff --git a/src/osd/PGLog.h b/src/osd/PGLog.h
@@ -1587,7 +1587,7 @@ struct PGLog : DoutPrefixProvider {
       });
     if (info.pgid.is_no_shard()) {
       // replicated pool pg does not persist this key
-      assert(on_disk_rollback_info_trimmed_to == eversion_t());
+      ceph_assert(on_disk_rollback_info_trimmed_to == eversion_t());
       on_disk_rollback_info_trimmed_to = info.last_update;
     }
     log = IndexedLog(
diff --git a/src/osd/PeeringState.cc b/src/osd/PeeringState.cc
@@ -1247,7 +1247,7 @@ void PeeringState::send_lease()
 
 void PeeringState::proc_lease(const pg_lease_t& l)
 {
-  assert(HAVE_FEATURE(upacting_features, SERVER_OCTOPUS));
+  ceph_assert(HAVE_FEATURE(upacting_features, SERVER_OCTOPUS));
   if (!is_nonprimary()) {
     psdout(20) << "no-op, !nonprimary" << dendl;
     return;
@@ -1289,7 +1289,7 @@ void PeeringState::proc_lease(const pg_lease_t& l)
 
 void PeeringState::proc_lease_ack(int from, const pg_lease_ack_t& a)
 {
-  assert(HAVE_FEATURE(upacting_features, SERVER_OCTOPUS));
+  ceph_assert(HAVE_FEATURE(upacting_features, SERVER_OCTOPUS));
   auto now = pl->get_mnow();
   bool was_min = false;
   for (unsigned i = 0; i < acting.size(); ++i) {
@@ -1315,7 +1315,7 @@ void PeeringState::proc_lease_ack(int from, const pg_lease_ack_t& a)
 
 void PeeringState::proc_renew_lease()
 {
-  assert(HAVE_FEATURE(upacting_features, SERVER_OCTOPUS));
+  ceph_assert(HAVE_FEATURE(upacting_features, SERVER_OCTOPUS));
   renew_lease(pl->get_mnow());
   if (actingset.size() > 1) {
     send_lease();
@@ -1327,7 +1327,7 @@ void PeeringState::proc_renew_lease()
 
 void PeeringState::recalc_readable_until()
 {
-  assert(is_primary());
+  ceph_assert(is_primary());
   ceph::signedspan min = readable_until_ub_sent;
   for (unsigned i = 0; i < acting.size(); ++i) {
     if (acting[i] == pg_whoami.osd || acting[i] == CRUSH_ITEM_NONE) {
@@ -1347,7 +1347,7 @@ void PeeringState::recalc_readable_until()
 
 bool PeeringState::check_prior_readable_down_osds(const OSDMapRef& map)
 {
-  assert(HAVE_FEATURE(upacting_features, SERVER_OCTOPUS));
+  ceph_assert(HAVE_FEATURE(upacting_features, SERVER_OCTOPUS));
   bool changed = false;
   auto p = prior_readable_down_osds.begin();
   while (p != prior_readable_down_osds.end()) {
@@ -1762,7 +1762,7 @@ PeeringState::select_replicated_primary(
       !primary->second.is_incomplete() &&
       primary->second.last_update >=
         auth_log_shard->second.log_tail) {
-    assert(HAVE_FEATURE(osdmap->get_up_osd_features(), SERVER_NAUTILUS));
+    ceph_assert(HAVE_FEATURE(osdmap->get_up_osd_features(), SERVER_NAUTILUS));
     auto approx_missing_objects =
       primary->second.stats.stats.sum.num_objects_missing;
     auto auth_version = auth_log_shard->second.last_update.version;
@@ -1961,7 +1961,7 @@ class bucket_candidates_t {
 public:
   void add_osd(osd_ord_t ord, osd_id_t osd) {
     // osds will be added in smallest to largest order
-    assert(osds.empty() || osds.back().first <= ord);
+    ceph_assert(osds.empty() || osds.back().first <= ord);
     osds.push_back(std::make_pair(ord, osd));
   }
   osd_id_t pop_osd() {
@@ -2295,7 +2295,7 @@ void PeeringState::choose_async_recovery_ec(
     // past the authoritative last_update the same as those equal to it.
     version_t auth_version = auth_info.last_update.version;
     version_t candidate_version = shard_info.last_update.version;
-    assert(HAVE_FEATURE(osdmap->get_up_osd_features(), SERVER_NAUTILUS));
+    ceph_assert(HAVE_FEATURE(osdmap->get_up_osd_features(), SERVER_NAUTILUS));
     auto approx_missing_objects =
       shard_info.stats.stats.sum.num_objects_missing;
     if (auth_version > candidate_version) {
@@ -2353,7 +2353,7 @@ void PeeringState::choose_async_recovery_replicated(
     // logs plus historical missing objects as the cost of recovery
     version_t auth_version = auth_info.last_update.version;
     version_t candidate_version = shard_info.last_update.version;
-    assert(HAVE_FEATURE(osdmap->get_up_osd_features(), SERVER_NAUTILUS));
+    ceph_assert(HAVE_FEATURE(osdmap->get_up_osd_features(), SERVER_NAUTILUS));
     auto approx_missing_objects =
       shard_info.stats.stats.sum.num_objects_missing;
     if (auth_version > candidate_version) {
@@ -2886,7 +2886,7 @@ void PeeringState::activate(
     purged.intersection_of(to_trim, info.purged_snaps);
     to_trim.subtract(purged);
 
-    assert(HAVE_FEATURE(upacting_features, SERVER_OCTOPUS));
+    ceph_assert(HAVE_FEATURE(upacting_features, SERVER_OCTOPUS));
     renew_lease(pl->get_mnow());
     // do not schedule until we are actually activated
 
@@ -4584,7 +4584,7 @@ void PeeringState::recover_got(
     psdout(10) << "last_complete now " << info.last_complete
 	       << " log.complete_to at end" << dendl;
     //below is not true in the repair case.
-    //assert(missing.num_missing() == 0);  // otherwise, complete_to was wrong.
+    //ceph_assert(missing.num_missing() == 0);  // otherwise, complete_to was wrong.
     ceph_assert(info.last_complete == info.last_update);
   }
 
@@ -4774,8 +4774,8 @@ void PeeringState::calc_trim_to()
     }
     psdout(10) << "calc_trim_to " << pg_trim_to << " -> " << new_trim_to << dendl;
     pg_trim_to = new_trim_to;
-    assert(pg_trim_to <= pg_log.get_head());
-    assert(pg_trim_to <= min_last_complete_ondisk);
+    ceph_assert(pg_trim_to <= pg_log.get_head());
+    ceph_assert(pg_trim_to <= min_last_complete_ondisk);
   }
 }
 
@@ -6584,7 +6584,7 @@ boost::statechart::result PeeringState::Active::react(const AllReplicasActivated
       if (merge_target) {
 	pg_t src = pgid;
 	src.set_ps(ps->pool.info.get_pg_num_pending());
-	assert(src.get_parent() == pgid);
+	ceph_assert(src.get_parent() == pgid);
 	pl->set_not_ready_to_merge_target(pgid, src);
       } else {
 	pl->set_not_ready_to_merge_source(pgid);
@@ -6679,7 +6679,7 @@ void PeeringState::Active::all_activated_and_committed()
   ceph_assert(!ps->acting_recovery_backfill.empty());
   ceph_assert(ps->blocked_by.empty());
 
-  assert(HAVE_FEATURE(ps->upacting_features, SERVER_OCTOPUS));
+  ceph_assert(HAVE_FEATURE(ps->upacting_features, SERVER_OCTOPUS));
   // this is overkill when the activation is quick, but when it is slow it
   // is important, because the lease was renewed by the activate itself but we
   // don't know how long ago that was, and simply scheduling now may leave
@@ -8069,7 +8069,7 @@ std::vector<pg_shard_t> PeeringState::get_replica_recovery_order() const
       continue;
     }
     auto pm = get_peer_missing().find(p);
-    assert(pm != get_peer_missing().end());
+    ceph_assert(pm != get_peer_missing().end());
     auto nm = pm->second.num_missing();
     if (nm != 0) {
       if (is_async_recovery_target(p)) {
diff --git a/src/osd/PeeringState.h b/src/osd/PeeringState.h
@@ -633,7 +633,7 @@ class PeeringState : public MissingLoc::MappingInfo {
     }
 
     PeeringCtxWrapper &get_recovery_ctx() {
-      assert(state->rctx);
+      ceph_assert(state->rctx);
       return *(state->rctx);
     }
 
@@ -2395,13 +2395,13 @@ class PeeringState : public MissingLoc::MappingInfo {
       return pg_log.get_missing();
     } else {
       auto it = peer_missing.find(peer);
-      assert(it != peer_missing.end());
+      ceph_assert(it != peer_missing.end());
       return it->second;
     }
   }
   const pg_info_t&get_peer_info(pg_shard_t peer) const {
     auto it = peer_info.find(peer);
-    assert(it != peer_info.end());
+    ceph_assert(it != peer_info.end());
     return it->second;
   }
   bool has_peer_info(pg_shard_t peer) const {
diff --git a/src/osd/PrimaryLogPG.cc b/src/osd/PrimaryLogPG.cc
@@ -852,7 +852,7 @@ void PrimaryLogPG::maybe_force_recovery()
 
 bool PrimaryLogPG::check_laggy(OpRequestRef& op)
 {
-  assert(HAVE_FEATURE(recovery_state.get_min_upacting_features(),
+  ceph_assert(HAVE_FEATURE(recovery_state.get_min_upacting_features(),
 		      SERVER_OCTOPUS));
   if (state_test(PG_STATE_WAIT)) {
     dout(10) << __func__ << " PG is WAIT state" << dendl;
@@ -884,7 +884,7 @@ bool PrimaryLogPG::check_laggy(OpRequestRef& op)
 
 bool PrimaryLogPG::check_laggy_requeue(OpRequestRef& op)
 {
-  assert(HAVE_FEATURE(recovery_state.get_min_upacting_features(),
+  ceph_assert(HAVE_FEATURE(recovery_state.get_min_upacting_features(),
 		      SERVER_OCTOPUS));
   if (!state_test(PG_STATE_WAIT) && !state_test(PG_STATE_LAGGY)) {
     return true; // not laggy
@@ -3988,7 +3988,7 @@ void PrimaryLogPG::finish_proxy_write(hobject_t oid, ceph_tid_t tid, int r)
 
   if (!pwop->sent_reply) {
     // send commit.
-    assert(pwop->ctx->reply == nullptr);
+    ceph_assert(pwop->ctx->reply == nullptr);
     MOSDOpReply *reply = new MOSDOpReply(m, r, get_osdmap_epoch(), 0,
 					 true /* we claim it below */);
     reply->set_reply_versions(eversion_t(), pwop->user_version);
@@ -10729,7 +10729,7 @@ std::pair<int, hobject_t> PrimaryLogPG::get_fpoid_from_chunk(
       case pg_pool_t::TYPE_FINGERPRINT_SHA512:
 	return ceph::crypto::digest<ceph::crypto::SHA512>(chunk).to_str();
       default:
-	assert(0 == "unrecognized fingerprint type");
+	ceph_assert(0 == "unrecognized fingerprint type");
 	return {};
     }
   }();    
@@ -14109,7 +14109,7 @@ uint64_t PrimaryLogPG::recover_backfill(
 	dout(20) << " BACKFILL keeping " << check
 		 << " with ver " << obj_v
 		 << " on peers " << keep_ver_targs << dendl;
-	//assert(!waiting_for_degraded_object.count(check));
+	//ceph_assert(!waiting_for_degraded_object.count(check));
       }
       if (!need_ver_targs.empty() || !missing_targs.empty()) {
 	ObjectContextRef obc = get_object_context(backfill_info.begin, false);
diff --git a/src/osd/ReplicatedBackend.cc b/src/osd/ReplicatedBackend.cc
diff --git a/src/osd/SnapMapper.cc b/src/osd/SnapMapper.cc
diff --git a/src/osd/objclass.cc b/src/osd/objclass.cc
diff --git a/src/osd/scheduler/mClockScheduler.cc b/src/osd/scheduler/mClockScheduler.cc
diff --git a/src/osd/scrubber/scrub_machine.h b/src/osd/scrubber/scrub_machine.h

Original file line number	Diff line number	Diff line change
`@@ -1444,7 +1444,7 @@ struct ECClassicalOp : ECCommonL::RMWPipeline::Op {`
`1444`	`1444`	`DoutPrefixProvider *dpp,`
`1445`	`1445`	`const ceph_release_t require_osd_release) final`
`1446`	`1446`	`{`
`1447`		`- assert(t);`
	`1447`	`+ ceph_assert(t);`
`1448`	`1448`	`ECTransactionL::generate_transactions(`
`1449`	`1449`	`t.get(),`
`1450`	`1450`	`plan,`
Original file line number	Diff line number	Diff line change
`@@ -1951,7 +1951,7 @@ void OSDService::set_ready_to_merge_source(PG *pg, eversion_t version)`
`1951`	`1951`	`std::lock_guard l(merge_lock);`
`1952`	`1952`	`dout(10) << __func__ << " " << pg->pg_id << dendl;`
`1953`	`1953`	`ready_to_merge_source[pg->pg_id.pgid] = version;`
`1954`		`- assert(not_ready_to_merge_source.count(pg->pg_id.pgid) == 0);`
	`1954`	`+ ceph_assert(not_ready_to_merge_source.count(pg->pg_id.pgid) == 0);`
`1955`	`1955`	`_send_ready_to_merge();`
`1956`	`1956`	`}`
`1957`	`1957`
`@@ -1966,7 +1966,7 @@ void OSDService::set_ready_to_merge_target(PG *pg,`
`1966`	`1966`	`make_tuple(version,`
`1967`	`1967`	`last_epoch_started,`
`1968`	`1968`	`last_epoch_clean)));`
`1969`		`- assert(not_ready_to_merge_target.count(pg->pg_id.pgid) == 0);`
	`1969`	`+ ceph_assert(not_ready_to_merge_target.count(pg->pg_id.pgid) == 0);`
`1970`	`1970`	`_send_ready_to_merge();`
`1971`	`1971`	`}`
`1972`	`1972`
`@@ -1975,7 +1975,7 @@ void OSDService::set_not_ready_to_merge_source(pg_t source)`
`1975`	`1975`	`std::lock_guard l(merge_lock);`
`1976`	`1976`	`dout(10) << __func__ << " " << source << dendl;`
`1977`	`1977`	`not_ready_to_merge_source.insert(source);`
`1978`		`- assert(ready_to_merge_source.count(source) == 0);`
	`1978`	`+ ceph_assert(ready_to_merge_source.count(source) == 0);`
`1979`	`1979`	`_send_ready_to_merge();`
`1980`	`1980`	`}`
`1981`	`1981`
`@@ -1984,7 +1984,7 @@ void OSDService::set_not_ready_to_merge_target(pg_t target, pg_t source)`
`1984`	`1984`	`std::lock_guard l(merge_lock);`
`1985`	`1985`	`dout(10) << __func__ << " " << target << " source " << source << dendl;`
`1986`	`1986`	`not_ready_to_merge_target[target] = source;`
`1987`		`- assert(ready_to_merge_target.count(target) == 0);`
	`1987`	`+ ceph_assert(ready_to_merge_target.count(target) == 0);`
`1988`	`1988`	`_send_ready_to_merge();`
`1989`	`1989`	`}`
`1990`	`1990`
`@@ -4055,13 +4055,13 @@ int OSD::init()`
`4055`	`4055`	`for (auto shard : shards) {`
`4056`	`4056`	`shard->prime_splits(osdmap, &new_children);`
`4057`	`4057`	`}`
`4058`		`- assert(new_children.empty());`
	`4058`	`+ ceph_assert(new_children.empty());`
`4059`	`4059`	`}`
`4060`	`4060`	`if (!merge_pgs.empty()) {`
`4061`	`4061`	`for (auto shard : shards) {`
`4062`	`4062`	`shard->prime_merges(osdmap, &merge_pgs);`
`4063`	`4063`	`}`
`4064`		`- assert(merge_pgs.empty());`
	`4064`	`+ ceph_assert(merge_pgs.empty());`
`4065`	`4065`	`}`
`4066`	`4066`	`}`
`4067`	`4067`	`}`
`@@ -5449,7 +5449,7 @@ void OSD::load_pgs()`
`5449`	`5449`	`}`
`5450`	`5450`	`{`
`5451`	`5451`	`uint32_t shard_index = pgid.hash_to_shard(shards.size());`
`5452`		`- assert(NULL != shards[shard_index]);`
	`5452`	`+ ceph_assert(NULL != shards[shard_index]);`
`5453`	`5453`	`store->set_collection_commit_queue(pg->coll, &(shards[shard_index]->context_queue));`
`5454`	`5454`	`}`
`5455`	`5455`
`@@ -5518,7 +5518,7 @@ PGRef OSD::handle_pg_create_info(const OSDMapRef& osdmap,`
`5518`	`5518`
`5519`	`5519`	`{`
`5520`	`5520`	`uint32_t shard_index = pgid.hash_to_shard(shards.size());`
`5521`		`- assert(NULL != shards[shard_index]);`
	`5521`	`+ ceph_assert(NULL != shards[shard_index]);`
`5522`	`5522`	`store->set_collection_commit_queue(pg->coll, &(shards[shard_index]->context_queue));`
`5523`	`5523`	`}`
`5524`	`5524`
`@@ -5673,7 +5673,7 @@ void OSD::_add_heartbeat_peer(int p)`
`5673`	`5673`	`pair<ConnectionRef,ConnectionRef> cons = service.get_con_osd_hb(p, get_osdmap_epoch());`
`5674`	`5674`	`if (!cons.first)`
`5675`	`5675`	`return;`
`5676`		`- assert(cons.second);`
	`5676`	`+ ceph_assert(cons.second);`
`5677`	`5677`
`5678`	`5678`	`hi = &heartbeat_peers[p];`
`5679`	`5679`	`hi->peer = p;`
`@@ -7943,7 +7943,7 @@ MPGStats* OSD::collect_pg_stats()`
`7943`	`7943`	`per_pool_stats = false;`
`7944`	`7944`	`break;`
`7945`	`7945`	`} else {`
`7946`		`- assert(r >= 0);`
	`7946`	`+ ceph_assert(r >= 0);`
`7947`	`7947`	`m->pool_stat[p] = st;`
`7948`	`7948`	`}`
`7949`	`7949`	`}`
`@@ -9365,7 +9365,7 @@ void OSD::split_pgs(`
`9365`	`9365`
`9366`	`9366`	`{`
`9367`	`9367`	`uint32_t shard_index = i->hash_to_shard(shards.size());`
`9368`		`- assert(NULL != shards[shard_index]);`
	`9368`	`+ ceph_assert(NULL != shards[shard_index]);`
`9369`	`9369`	`store->set_collection_commit_queue(child->coll, &(shards[shard_index]->context_queue));`
`9370`	`9370`	`}`
`9371`	`9371`
Original file line number	Diff line number	Diff line change
`@@ -893,7 +893,7 @@ class OSDMap {`
`893`	`893`	`}`
`894`	`894`
`895`	`895`	`bool exists(int osd) const {`
`896`		`- //assert(osd >= 0);`
	`896`	`+ //ceph_assert(osd >= 0);`
`897`	`897`	`return osd >= 0 && osd < max_osd && (osd_state[osd] & CEPH_OSD_EXISTS);`
`898`	`898`	`}`
`899`	`899`
Original file line number	Diff line number	Diff line change
`@@ -1178,7 +1178,7 @@ namespace {`
`1178`	`1178`	`}).then([this] {`
`1179`	`1179`	`if (info.pgid.is_no_shard()) {`
`1180`	`1180`	`// replicated pool pg does not persist this key`
`1181`		`- assert(on_disk_rollback_info_trimmed_to == eversion_t());`
	`1181`	`+ ceph_assert(on_disk_rollback_info_trimmed_to == eversion_t());`
`1182`	`1182`	`on_disk_rollback_info_trimmed_to = info.last_update;`
`1183`	`1183`	`}`
`1184`	`1184`	`log = PGLog::IndexedLog(`
Original file line number	Diff line number	Diff line change
`@@ -1587,7 +1587,7 @@ struct PGLog : DoutPrefixProvider {`
`1587`	`1587`	`});`
`1588`	`1588`	`if (info.pgid.is_no_shard()) {`
`1589`	`1589`	`// replicated pool pg does not persist this key`
`1590`		`- assert(on_disk_rollback_info_trimmed_to == eversion_t());`
	`1590`	`+ ceph_assert(on_disk_rollback_info_trimmed_to == eversion_t());`
`1591`	`1591`	`on_disk_rollback_info_trimmed_to = info.last_update;`
`1592`	`1592`	`}`
`1593`	`1593`	`log = IndexedLog(`
Original file line number	Diff line number	Diff line change
`@@ -633,7 +633,7 @@ class PeeringState : public MissingLoc::MappingInfo {`
`633`	`633`	`}`
`634`	`634`
`635`	`635`	`PeeringCtxWrapper &get_recovery_ctx() {`
`636`		`- assert(state->rctx);`
	`636`	`+ ceph_assert(state->rctx);`
`637`	`637`	`return *(state->rctx);`
`638`	`638`	`}`
`639`	`639`
`@@ -2395,13 +2395,13 @@ class PeeringState : public MissingLoc::MappingInfo {`
`2395`	`2395`	`return pg_log.get_missing();`
`2396`	`2396`	`} else {`
`2397`	`2397`	`auto it = peer_missing.find(peer);`
`2398`		`- assert(it != peer_missing.end());`
	`2398`	`+ ceph_assert(it != peer_missing.end());`
`2399`	`2399`	`return it->second;`
`2400`	`2400`	`}`
`2401`	`2401`	`}`
`2402`	`2402`	`const pg_info_t&get_peer_info(pg_shard_t peer) const {`
`2403`	`2403`	`auto it = peer_info.find(peer);`
`2404`		`- assert(it != peer_info.end());`
	`2404`	`+ ceph_assert(it != peer_info.end());`
`2405`	`2405`	`return it->second;`
`2406`	`2406`	`}`
`2407`	`2407`	`bool has_peer_info(pg_shard_t peer) const {`