+ logger().debug(
+--- ceph-17.2.3/src/crimson/os/seastore/journal.cc.orig 2022-07-28 23:52:12.000000000 +0200
++++ ceph-17.2.3/src/crimson/os/seastore/journal.cc 2022-09-09 21:45:01.061536954 +0200
+@@ -2,6 +2,7 @@
+ // vim: ts=8 sw=2 smarttab
+
+ #include <iostream>
++#include <fmt/os.h>
+
+ #include <boost/iterator/counting_iterator.hpp>
+
+--- ceph-17.2.3/src/crimson/os/seastore/seastore.cc.orig 2022-07-28 23:52:12.000000000 +0200
++++ ceph-17.2.3/src/crimson/os/seastore/seastore.cc 2022-09-12 21:36:15.057012562 +0200
+@@ -13,9 +13,11 @@
+ #include <seastar/core/fstream.hh>
+ #include <seastar/core/shared_mutex.hh>
+
++#include "common/hobject_fmt.h"
+ #include "common/safe_io.h"
+ #include "include/stringify.h"
+ #include "os/Transaction.h"
++#include "osd/osd_types_fmt.h"
+
+ #include "crimson/common/buffer_io.h"
+
+@@ -124,7 +126,7 @@ void SeaStore::register_metrics()
+
+ for (auto& [op_type, label] : labels_by_op_type) {
+ auto desc = fmt::format("latency of seastore operation (optype={})",
+- op_type);
++ static_cast<uint8_t>(op_type));
+ metrics.add_group(
+ "seastore",
+ {
+--- ceph-17.2.3/src/crimson/os/seastore/seastore_types.cc.orig 2022-07-28 23:52:12.000000000 +0200
++++ ceph-17.2.3/src/crimson/os/seastore/seastore_types.cc 2022-09-09 20:12:53.796095116 +0200
+@@ -12,6 +12,9 @@ seastar::logger& logger() {
+
+ }
+
++template <>
++struct fmt::formatter<ceph::buffer::error> : ostream_formatter {};
++
+ namespace crimson::os::seastore {
+
+ std::ostream& operator<<(std::ostream& out, const seastore_meta_t& meta)
+--- ceph-17.2.3/src/crimson/os/seastore/collection_manager/collection_flat_node.h.orig 2022-07-28 23:52:12.000000000 +0200
++++ ceph-17.2.3/src/crimson/os/seastore/collection_manager/collection_flat_node.h 2022-09-11 14:36:42.815251945 +0200
+@@ -182,3 +182,6 @@ struct CollectionNode
+ };
+ using CollectionNodeRef = CollectionNode::CollectionNodeRef;
+ }
++
++template <>
++struct fmt::formatter<crimson::os::seastore::collection_manager::CollectionNode> : ostream_formatter {};
+--- ceph-17.2.3/src/crimson/os/seastore/collection_manager/collection_flat_node.cc.orig 2022-07-28 23:52:12.000000000 +0200
++++ ceph-17.2.3/src/crimson/os/seastore/collection_manager/collection_flat_node.cc 2022-09-12 21:40:23.250020447 +0200
+@@ -3,6 +3,7 @@
+
+ #include "include/buffer.h"
+ #include "osd/osd_types.h"
++#include "osd/osd_types_fmt.h"
+ #include "crimson/os/seastore/transaction_manager.h"
+ #include "crimson/os/seastore/collection_manager/collection_flat_node.h"
+
+--- ceph-17.2.3/src/crimson/os/seastore/lba_manager/btree/btree_range_pin.h.orig 2022-07-28 23:52:12.000000000 +0200
++++ ceph-17.2.3/src/crimson/os/seastore/lba_manager/btree/btree_range_pin.h 2022-09-10 07:02:50.047200663 +0200
+@@ -4,6 +4,7 @@
+ #pragma once
+
+ #include <boost/intrusive/set.hpp>
++#include <fmt/ostream.h>
+
+ #include "crimson/os/seastore/cached_extent.h"
+ #include "crimson/os/seastore/seastore_types.h"
+@@ -290,3 +291,6 @@ public:
+ };
+
+ }
++
++template <>
++struct fmt::formatter<crimson::os::seastore::lba_manager::btree::btree_range_pin_t> : ostream_formatter {};
+--- ceph-17.2.3/src/crimson/os/seastore/lba_manager/btree/lba_btree_node.h.orig 2022-07-28 23:52:12.000000000 +0200
++++ ceph-17.2.3/src/crimson/os/seastore/lba_manager/btree/lba_btree_node.h 2022-09-10 07:35:43.533763577 +0200
+@@ -563,3 +563,9 @@ struct LBALeafNode
+ using LBALeafNodeRef = TCachedExtentRef<LBALeafNode>;
+
+ }
++
++template <>
++struct fmt::formatter<crimson::os::seastore::lba_manager::btree::LBAInternalNode> : ostream_formatter {};
++
++template <>
++struct fmt::formatter<crimson::os::seastore::lba_manager::btree::LBALeafNode> : ostream_formatter {};
+--- ceph-17.2.3/src/crimson/os/seastore/omap_manager/btree/omap_btree_node.h.orig 2022-07-28 23:52:12.000000000 +0200
++++ ceph-17.2.3/src/crimson/os/seastore/omap_manager/btree/omap_btree_node.h 2022-09-10 08:25:44.417337428 +0200
+@@ -114,3 +114,6 @@ omap_load_extent_iertr::future<OMapNodeR
+ omap_load_extent(omap_context_t oc, laddr_t laddr, depth_t depth);
+
+ }
++
++template <>
++struct fmt::formatter<crimson::os::seastore::omap_manager::OMapNode> : ostream_formatter {};
+--- ceph-17.2.3/src/crimson/os/seastore/omap_manager/btree/omap_btree_node_impl.h.orig 2022-07-28 23:52:12.000000000 +0200
++++ ceph-17.2.3/src/crimson/os/seastore/omap_manager/btree/omap_btree_node_impl.h 2022-09-10 13:55:41.723892064 +0200
+@@ -235,3 +235,15 @@ using OMapLeafNodeRef = OMapLeafNode::OM
+ std::ostream &operator<<(std::ostream &out, const omap_inner_key_t &rhs);
+ std::ostream &operator<<(std::ostream &out, const omap_leaf_key_t &rhs);
+ }
++
++template <>
++struct fmt::formatter<crimson::os::seastore::omap_manager::OMapInnerNode> : ostream_formatter {};
++
++template <>
++struct fmt::formatter<crimson::os::seastore::omap_manager::OMapLeafNode> : ostream_formatter {};
++
++template <>
++struct fmt::formatter<boost::intrusive_ptr<crimson::os::seastore::omap_manager::OMapInnerNode>> : ostream_formatter {};
++
++template <>
++struct fmt::formatter<boost::intrusive_ptr<crimson::os::seastore::omap_manager::OMapLeafNode>> : ostream_formatter {};
+--- ceph-17.2.3/src/crimson/os/seastore/omap_manager/btree/btree_omap_manager.cc.orig 2022-07-28 23:52:12.000000000 +0200
++++ ceph-17.2.3/src/crimson/os/seastore/omap_manager/btree/btree_omap_manager.cc 2022-09-10 07:53:44.517113694 +0200
+@@ -130,7 +130,7 @@ BtreeOMapManager::omap_set_key(
+ const std::string &key,
+ const ceph::bufferlist &value)
+ {
+- logger().debug("{}: {} -> {}", __func__, key, value);
++ logger().debug("{}: {} -> {}", __func__, key, fmt::streamed(value));
+ return get_omap_root(
+ get_omap_context(t, omap_root.hint),
+ omap_root
+--- ceph-17.2.3/src/crimson/os/seastore/omap_manager/btree/omap_btree_node_impl.cc.orig 2022-07-28 23:52:12.000000000 +0200
++++ ceph-17.2.3/src/crimson/os/seastore/omap_manager/btree/omap_btree_node_impl.cc 2022-09-10 12:21:38.205877267 +0200
+@@ -136,7 +136,7 @@ OMapInnerNode::insert(
+ const std::string &key,
+ const ceph::bufferlist &value)
+ {
+- logger().debug("OMapInnerNode: {} {}->{}", __func__, key, value);
++ logger().debug("OMapInnerNode: {} {}->{}", __func__, key, fmt::streamed(value));
+ auto child_pt = get_containing_child(key);
+ assert(child_pt != iter_end());
+ auto laddr = child_pt->get_val();
+@@ -432,7 +432,7 @@ OMapLeafNode::insert(
+ const std::string &key,
+ const ceph::bufferlist &value)
+ {
+- logger().debug("OMapLeafNode: {}, {} -> {}", __func__, key, value);
++ logger().debug("OMapLeafNode: {}, {} -> {}", __func__, key, fmt::streamed(value));
+ bool overflow = extent_will_overflow(key.size(), value.length());
+ if (!overflow) {
+ if (!is_pending()) {
+--- ceph-17.2.3/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_accessor.h.orig 2022-07-28 23:52:12.000000000 +0200
++++ ceph-17.2.3/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_accessor.h 2022-09-10 21:53:11.326721372 +0200
+@@ -141,7 +141,7 @@ class DeltaRecorderT final: public Delta
+ SUBDEBUG(seastore_onode, "decoding SPLIT ...");
+ auto split_at = StagedIterator::decode(
+ mut.get_read(), mut.get_length(), delta);
+- SUBDEBUG(seastore_onode, "apply split_at={} ...", split_at);
++ SUBDEBUG(seastore_onode, "apply split_at={} ...", fmt::streamed(split_at));
+ layout_t::split(mut, stage, split_at);
+ break;
+ }
+@@ -159,7 +159,7 @@ class DeltaRecorderT final: public Delta
+ SUBDEBUG(seastore_onode,
+ "apply split_at={}, {}, {}, insert_pos({}), insert_stage={}, "
+ "insert_size={}B ...",
+- split_at, key, value, insert_pos, insert_stage, insert_size);
++ fmt::streamed(split_at), key, value, insert_pos, insert_stage, insert_size);
+ layout_t::template split_insert<KeyT::HOBJ>(
+ mut, stage, split_at, key, value, insert_pos, insert_stage, insert_size);
+ break;
+@@ -206,13 +206,13 @@ class DeltaRecorderT final: public Delta
+ default:
+ SUBERROR(seastore_onode,
+ "got unknown op {} when replay {}",
+- op, node);
++ static_cast<uint8_t>(op), node);
+ ceph_abort("fatal error");
+ }
+ } catch (buffer::error& e) {
+ SUBERROR(seastore_onode,
+ "got decode error {} when replay {}",
+- e, node);
++ fmt::streamed(e), node);
+ ceph_abort("fatal error");
+ }
+ }
+--- ceph-17.2.3/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_manager.h.orig 2022-07-28 23:52:12.000000000 +0200
++++ ceph-17.2.3/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_manager.h 2022-09-10 20:22:25.681931141 +0200
+@@ -99,3 +99,6 @@ inline std::ostream& operator<<(std::ost
+ }
+
+ }
++
++template <>
++struct fmt::formatter<crimson::os::seastore::onode::NodeExtent> : ostream_formatter {};
+--- ceph-17.2.3/src/crimson/os/seastore/onode_manager/staged-fltree/node_layout.h.orig 2022-07-28 23:52:12.000000000 +0200
++++ ceph-17.2.3/src/crimson/os/seastore/onode_manager/staged-fltree/node_layout.h 2022-09-10 23:18:51.518511129 +0200
+@@ -716,7 +716,7 @@ class NodeLayoutT final : public Interna
+ SUBDEBUG(seastore_onode,
+ "-- located split_at({}), insert_pos({}), is_insert_left={}, "
+ "split_size={}B(target={}B, current={}B)",
+- split_at, insert_pos, is_insert_left,
++ fmt::streamed(split_at), insert_pos, is_insert_left,
+ split_size, target_split_size, filled_size());
+ // split_size can be larger than target_split_size in strategy B
+ // assert(split_size <= target_split_size);
+--- ceph-17.2.3/src/crimson/os/seastore/onode_manager/staged-fltree/tree_utils.h.orig 2022-07-28 23:52:12.000000000 +0200
++++ ceph-17.2.3/src/crimson/os/seastore/onode_manager/staged-fltree/tree_utils.h 2022-09-14 16:25:35.992674217 +0200
+@@ -304,7 +304,7 @@ class TreeBuilder {
+ logger().debug("[{}] insert {} -> {}",
+ iter_rd - kvs.random_begin(),
+ key_hobj_t{p_kv->key},
+- p_kv->value);
++ fmt::streamed(p_kv->value));
+ return tree->insert(
+ t, p_kv->key, {p_kv->value.get_payload_size()}
+ ).si_then([&t, this, p_kv](auto ret) {
+@@ -397,7 +397,7 @@ class TreeBuilder {
+ logger().debug("[{}] erase {} -> {}",
+ iter_rd - kvs.random_begin(),
+ key_hobj_t{p_kv->key},
+- p_kv->value);
++ fmt::streamed(p_kv->value));
+ return tree->erase(t, p_kv->key
+ ).si_then([&t, this, p_kv] (auto size) {
+ ceph_assert(size == 1);
+@@ -497,7 +497,7 @@ class TreeBuilder {
+ eagain_ifuture<> get_stats(Transaction& t) {
+ return tree->get_stats_slow(t
+ ).si_then([](auto stats) {
+- logger().warn("{}", stats);
++ logger().warn("{}", fmt::streamed(stats));
+ });
+ }
+
+--- ceph-17.2.3/src/crimson/os/seastore/onode_manager/staged-fltree/value.h.orig 2022-07-28 23:52:12.000000000 +0200
++++ ceph-17.2.3/src/crimson/os/seastore/onode_manager/staged-fltree/value.h 2022-09-10 20:44:01.346243614 +0200
+@@ -330,3 +330,9 @@ std::unique_ptr<ValueDeltaRecorder>
+ build_value_recorder_by_type(ceph::bufferlist& encoded, const value_magic_t& magic);
+
+ }
++
++template <>
++struct fmt::formatter<crimson::os::seastore::onode::value_config_t> : ostream_formatter {};
++
++template <>
++struct fmt::formatter<crimson::os::seastore::onode::value_header_t> : ostream_formatter {};
+--- ceph-17.2.3/src/crimson/os/seastore/onode_manager/staged-fltree/fltree_onode_manager.cc.orig 2022-07-28 23:52:12.000000000 +0200
++++ ceph-17.2.3/src/crimson/os/seastore/onode_manager/staged-fltree/fltree_onode_manager.cc 2022-09-11 13:59:47.892898649 +0200
+@@ -1,6 +1,7 @@
+ // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:nil -*-
+ // vim: ts=8 sw=2 smarttab
+
++#include "common/hobject_fmt.h"
+ #include "crimson/os/seastore/logging.h"
+
+ #include "crimson/os/seastore/onode_manager/staged-fltree/fltree_onode_manager.h"
+--- ceph-17.2.3/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_manager/dummy.h.orig 2022-07-28 23:52:12.000000000 +0200
++++ ceph-17.2.3/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_manager/dummy.h 2022-09-10 20:23:37.035656315 +0200
+@@ -190,3 +190,6 @@ class DummyNodeExtentManager final: publ
+ };
+
+ }
++
++template <>
++struct fmt::formatter<crimson::os::seastore::onode::DummyNodeExtent> : ostream_formatter {};
+--- ceph-17.2.3/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_manager/seastore.h.orig 2022-07-28 23:52:12.000000000 +0200
++++ ceph-17.2.3/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_manager/seastore.h 2022-09-10 20:35:15.305445076 +0200
+@@ -217,3 +217,6 @@ class SeastoreNodeExtentManager final: p
+ };
+
+ }
++
++template <>
++struct fmt::formatter<crimson::os::seastore::onode::SeastoreNodeExtent> : ostream_formatter {};
+--- ceph-17.2.3/src/crimson/os/seastore/onode_manager/staged-fltree/stages/key_layout.h.orig 2022-07-28 23:52:12.000000000 +0200
++++ ceph-17.2.3/src/crimson/os/seastore/onode_manager/staged-fltree/stages/key_layout.h 2022-09-10 18:15:40.701599795 +0200
+@@ -941,3 +941,9 @@ void ns_oid_view_t::test_append(const fu
+ }
+
+ }
++
++template <>
++struct fmt::formatter<crimson::os::seastore::onode::key_hobj_t> : ostream_formatter {};
++
++template <>
++struct fmt::formatter<crimson::os::seastore::onode::key_view_t> : ostream_formatter {};
+--- ceph-17.2.3/src/crimson/os/seastore/onode_manager/staged-fltree/stages/stage_types.h.orig 2022-07-28 23:52:12.000000000 +0200
++++ ceph-17.2.3/src/crimson/os/seastore/onode_manager/staged-fltree/stages/stage_types.h 2022-09-10 19:52:32.398311751 +0200
+@@ -462,3 +462,9 @@ struct node_stats_t {
+ };
+
+ }
++
++template <>
++struct fmt::formatter<crimson::os::seastore::onode::MatchHistory> : ostream_formatter {};
++
++template <crimson::os::seastore::onode::match_stage_t STAGE>
++struct fmt::formatter<crimson::os::seastore::onode::staged_position_t<STAGE>> : ostream_formatter {};
+--- ceph-17.2.3/src/crimson/os/seastore/random_block_manager/nvme_manager.cc.orig 2022-07-28 23:52:12.000000000 +0200
++++ ceph-17.2.3/src/crimson/os/seastore/random_block_manager/nvme_manager.cc 2022-09-11 19:09:02.343128795 +0200
+@@ -154,7 +154,7 @@ NVMeManager::mkfs_ertr::future<> NVMeMan
+ super.blocks_per_segment = config.blocks_per_segment;
+ super.device_id = config.device_id;
+
+- logger().debug(" super {} ", super);
++ logger().debug(" super {} ", fmt::streamed(super));
+ // write super block
+ return write_rbm_header().safe_then([this] {
+ return initialize_blk_alloc_area();
+@@ -227,7 +227,7 @@ NVMeManager::find_block_ret NVMeManager:
+ }
+ addr += super.block_size;
+ logger().debug("find_free_list: allocated: {} alloc_extent {}",
+- allocated, alloc_extent);
++ allocated, fmt::streamed(alloc_extent));
+ if (((uint64_t)size)/super.block_size == allocated) {
+ return seastar::stop_iteration::yes;
+ } else if (addr >= super.start_data_area) {
+@@ -271,7 +271,7 @@ NVMeManager::allocate_ret NVMeManager::a
+ return find_free_block(t, size
+ ).safe_then([this, &t] (auto alloc_extent) mutable
+ -> allocate_ertr::future<paddr_t> {
+- logger().debug("after find_free_block: allocated {}", alloc_extent);
++ logger().debug("after find_free_block: allocated {}", fmt::streamed(alloc_extent));
+ if (!alloc_extent.empty()) {
+ rbm_alloc_delta_t alloc_info;
+ for (auto p : alloc_extent) {
+@@ -626,7 +626,7 @@ NVMeManager::read_ertr::future<rbm_metad
+ return crimson::ct_error::input_output_error::make();
+ }
+ }
+- logger().debug(" got {} ", super);
++ logger().debug(" got {} ", fmt::streamed(super));
+ return read_ertr::future<rbm_metadata_header_t>(
+ read_ertr::ready_future_marker{},
+ super_block
+--- ceph-17.2.3/src/crimson/os/seastore/segment_manager/ephemeral.cc.orig 2022-07-28 23:52:12.000000000 +0200
++++ ceph-17.2.3/src/crimson/os/seastore/segment_manager/ephemeral.cc 2022-09-09 20:40:20.735269610 +0200
+@@ -96,7 +96,7 @@ EphemeralSegmentManager::init_ertr::futu
+ {
+ logger().debug(
+ "Initing ephemeral segment manager with config {}",
+- config);
++ fmt::streamed(config));
+
+ meta = seastore_meta_t{};
+
+--- ceph-17.2.3/src/crimson/osd/backfill_state.cc.orig 2022-07-28 23:52:12.000000000 +0200
++++ ceph-17.2.3/src/crimson/osd/backfill_state.cc 2022-09-11 20:11:11.288470838 +0200
+@@ -5,6 +5,7 @@
+ #include <boost/type_index.hpp>
+
+ #include "crimson/osd/backfill_state.h"
++#include "osd/osd_types_fmt.h"
+
+ namespace {
+ seastar::logger& logger() {
+@@ -423,7 +424,7 @@ boost::statechart::result
+ BackfillState::ReplicasScanning::react(ReplicaScanned evt)
+ {
+ logger().debug("{}: got scan result from osd={}, result={}",
+- __func__, evt.from, evt.result);
++ __func__, evt.from, fmt::streamed(evt.result));
+ // TODO: maybe we'll be able to move waiting_on_backfill from
+ // the machine to the state.
+ ceph_assert(peering_state().is_backfill_target(evt.from));
+--- ceph-17.2.3/src/crimson/osd/heartbeat.cc.orig 2022-07-28 23:52:12.000000000 +0200
++++ ceph-17.2.3/src/crimson/osd/heartbeat.cc 2022-09-11 20:44:43.140556321 +0200
+@@ -4,9 +4,11 @@
+ #include "heartbeat.h"
+
+ #include <boost/range/join.hpp>
++#include <fmt/os.h>
+
+ #include "messages/MOSDPing.h"
+ #include "messages/MOSDFailure.h"
++#include "msg/msg_fmt.h"
+
+ #include "crimson/common/config_proxy.h"
+ #include "crimson/common/formatter.h"
+@@ -17,6 +19,9 @@
+
+ #include "osd/OSDMap.h"
+
++template <>
++struct fmt::formatter<Heartbeat::Connection> : ostream_formatter {};
++
+ using std::set;
+ using std::string;
+ using crimson::common::local_conf;
+@@ -393,7 +398,7 @@ void Heartbeat::Connection::accepted(cri
+ if (!conn) {
+ if (accepted_conn->get_peer_addr() == listener.get_peer_addr(type)) {
+ logger().info("Heartbeat::Connection::accepted(): "
+- "{} racing resolved", *this);
++ "{} racing resolved", fmt::streamed(*this));
+ conn = accepted_conn;
+ set_connected();
+ }
+@@ -410,7 +415,7 @@ void Heartbeat::Connection::replaced()
+ conn = msgr.connect(replaced_conn->get_peer_addr(),
+ replaced_conn->get_peer_name());
+ racing_detected = true;
+- logger().warn("Heartbeat::Connection::replaced(): {} racing", *this);
++ logger().warn("Heartbeat::Connection::replaced(): {} racing", fmt::streamed(*this));
+ assert(conn != replaced_conn);
+ assert(conn->is_connected());
+ }
+--- ceph-17.2.3/src/crimson/osd/ops_executer.cc.orig 2022-07-28 23:52:12.000000000 +0200
++++ ceph-17.2.3/src/crimson/osd/ops_executer.cc 2022-09-12 18:50:57.937349213 +0200
+@@ -18,6 +18,9 @@
+ #include "crimson/osd/exceptions.h"
+ #include "crimson/osd/pg.h"
+ #include "crimson/osd/watch.h"
++#include "common/hobject_fmt.h"
++#include "msg/msg_fmt.h"
++#include "osd/osd_types_fmt.h"
+ #include "osd/ClassHandler.h"
+
+ namespace {
+--- ceph-17.2.3/src/crimson/osd/osd.cc.orig 2022-07-28 23:52:12.000000000 +0200
++++ ceph-17.2.3/src/crimson/osd/osd.cc 2022-09-11 21:59:01.223608155 +0200
+@@ -10,6 +10,7 @@
+ #include <boost/smart_ptr/make_local_shared.hpp>
+ #include <fmt/format.h>
+ #include <fmt/ostream.h>
++#include <fmt/os.h>
+ #include <seastar/core/timer.hh>
+
+ #include "common/pick_address.h"
+@@ -25,12 +26,14 @@
+ #include "messages/MOSDRepOpReply.h"
+ #include "messages/MOSDScrub2.h"
+ #include "messages/MPGStats.h"
++#include "msg/msg_fmt.h"
+
+ #include "os/Transaction.h"
+ #include "osd/ClassHandler.h"
+ #include "osd/OSDCap.h"
+ #include "osd/PGPeeringEvent.h"
+ #include "osd/PeeringState.h"
++#include "osd/osd_types_fmt.h"
+
+ #include "crimson/admin/osd_admin.h"
+ #include "crimson/admin/pg_commands.h"
+@@ -186,7 +189,7 @@ seastar::future<> OSD::mkfs(uuid_d osd_u
+ }).then([cluster_fsid, this] {
+ fmt::print("created object store {} for osd.{} fsid {}\n",
+ local_conf().get_val<std::string>("osd_data"),
+- whoami, cluster_fsid);
++ whoami, fmt::streamed(cluster_fsid));
+ return seastar::now();
+ });
+ }
+@@ -200,7 +203,7 @@ seastar::future<> OSD::_write_superblock
+ return meta_coll->load_superblock().then([this](OSDSuperblock&& sb) {
+ if (sb.cluster_fsid != superblock.cluster_fsid) {
+ logger().error("provided cluster fsid {} != superblock's {}",
+- sb.cluster_fsid, superblock.cluster_fsid);
++ fmt::streamed(sb.cluster_fsid), fmt::streamed(superblock.cluster_fsid));
+ throw std::invalid_argument("mismatched fsid");
+ }
+ if (sb.whoami != superblock.whoami) {
+@@ -214,8 +217,8 @@ seastar::future<> OSD::_write_superblock
+ logger().info(
+ "{} writing superblock cluster_fsid {} osd_fsid {}",
+ "_write_superblock",
+- superblock.cluster_fsid,
+- superblock.osd_fsid);
++ fmt::streamed(superblock.cluster_fsid),
++ fmt::streamed(superblock.osd_fsid));
+ return store.create_new_collection(coll_t::meta()).then([this] (auto ch) {
+ meta_coll = make_unique<OSDMeta>(ch, store);
+ ceph::os::Transaction t;
+@@ -495,13 +498,13 @@ seastar::future<> OSD::_add_me_to_crush(
+ };
+ return get_weight().then([this](auto weight) {
+ const crimson::crush::CrushLocation loc{make_unique<CephContext>().get()};
+- logger().info("{} crush location is {}", __func__, loc);
++ logger().info("{} crush location is {}", __func__, fmt::streamed(loc));
+ string cmd = fmt::format(R"({{
+ "prefix": "osd crush create-or-move",
+ "id": {},
+ "weight": {:.4f},
+ "args": [{}]
+- }})", whoami, weight, loc);
++ }})", whoami, weight, fmt::streamed(loc));
+ return monc->run_command(std::move(cmd), {});
+ }).then([](auto&& command_result) {
+ [[maybe_unused]] auto [code, message, out] = std::move(command_result);
+@@ -797,7 +800,7 @@ void OSD::handle_authentication(const En
+ {
+ // TODO: store the parsed cap and associate it with the connection
+ if (caps_info.allow_all) {
+- logger().debug("{} {} has all caps", __func__, name);
++ logger().debug("{} {} has all caps", __func__, fmt::streamed(name));
+ return;
+ }
+ if (caps_info.caps.length() > 0) {
+@@ -806,14 +809,14 @@ void OSD::handle_authentication(const En
+ try {
+ decode(str, p);
+ } catch (ceph::buffer::error& e) {
+- logger().warn("{} {} failed to decode caps string", __func__, name);
++ logger().warn("{} {} failed to decode caps string", __func__, fmt::streamed(name));
+ return;
+ }
+ OSDCap caps;
+ if (caps.parse(str)) {
+- logger().debug("{} {} has caps {}", __func__, name, str);
++ logger().debug("{} {} has caps {}", __func__, fmt::streamed(name), str);
+ } else {
+- logger().warn("{} {} failed to parse caps {}", __func__, name, str);
++ logger().warn("{} {} failed to parse caps {}", __func__, fmt::streamed(name), str);
+ }
+ }
+ }
+@@ -1051,7 +1054,7 @@ seastar::future<Ref<PG>> OSD::handle_pg_
+ seastar::future<> OSD::handle_osd_map(crimson::net::ConnectionRef conn,
+ Ref<MOSDMap> m)
+ {
+- logger().info("handle_osd_map {}", *m);
++ logger().info("handle_osd_map {}", fmt::streamed(*m));
+ if (m->fsid != superblock.cluster_fsid) {
+ logger().warn("fsid mismatched");
+ return seastar::now();
+@@ -1141,7 +1144,7 @@ seastar::future<> OSD::committed_osd_map
+ if (osdmap->is_up(whoami)) {
+ const auto up_from = osdmap->get_up_from(whoami);
+ logger().info("osd.{}: map e {} marked me up: up_from {}, bind_epoch {}, state {}",
+- whoami, osdmap->get_epoch(), up_from, bind_epoch, state);
++ whoami, osdmap->get_epoch(), up_from, bind_epoch, fmt::streamed(state));
+ if (bind_epoch < up_from &&
+ osdmap->get_addrs(whoami) == public_msgr->get_myaddrs() &&
+ state.is_booting()) {
+@@ -1184,7 +1187,7 @@ seastar::future<> OSD::committed_osd_map
+ return start_boot();
+ }
+ } else {
+- logger().info("osd.{}: now {}", whoami, state);
++ logger().info("osd.{}: now {}", whoami, fmt::streamed(state));
+ // XXX
+ return seastar::now();
+ }
+@@ -1246,7 +1249,7 @@ seastar::future<> OSD::handle_rep_op_rep
+ m->finish_decode();
+ pg->second->handle_rep_op_reply(conn, *m);
+ } else {
+- logger().warn("stale reply: {}", *m);
++ logger().warn("stale reply: {}", fmt::streamed(*m));
+ }
+ return seastar::now();
+ }
+--- ceph-17.2.3/src/crimson/osd/osd_meta.cc.orig 2022-07-28 23:52:12.000000000 +0200
++++ ceph-17.2.3/src/crimson/osd/osd_meta.cc 2022-09-11 22:06:32.387184583 +0200
+@@ -6,6 +6,7 @@
+ #include <fmt/format.h>
+ #include <fmt/ostream.h>
+
++#include "common/hobject_fmt.h"
+ #include "crimson/os/futurized_collection.h"
+ #include "crimson/os/futurized_store.h"
+ #include "os/Transaction.h"
+--- ceph-17.2.3/src/crimson/osd/pg.cc.orig 2022-07-28 23:52:12.000000000 +0200
++++ ceph-17.2.3/src/crimson/osd/pg.cc 2022-09-12 06:26:38.859890170 +0200
+@@ -11,15 +11,19 @@
+ #include <boost/range/algorithm/copy.hpp>
+ #include <boost/range/algorithm/max_element.hpp>
+ #include <boost/range/numeric.hpp>
++#include <fmt/chrono.h>
+ #include <fmt/format.h>
++#include <fmt/os.h>
+ #include <fmt/ostream.h>
+
++#include "common/hobject_fmt.h"
+ #include "messages/MOSDOp.h"
+ #include "messages/MOSDOpReply.h"
+ #include "messages/MOSDRepOp.h"
+ #include "messages/MOSDRepOpReply.h"
+
+ #include "osd/OSDMap.h"
++#include "osd/osd_types_fmt.h"
+
+ #include "os/Transaction.h"
+
+@@ -768,7 +772,7 @@ PG::do_osd_ops(
+ reply->add_flags(CEPH_OSD_FLAG_ACK | CEPH_OSD_FLAG_ONDISK);
+ logger().debug(
+ "do_osd_ops: {} - object {} sending reply",
+- *m,
++ fmt::streamed(*m),
+ m->get_hobj());
+ return do_osd_ops_iertr::make_ready_future<MURef<MOSDOpReply>>(
+ std::move(reply));
+@@ -1181,7 +1185,7 @@ seastar::future<> PG::stop()
+ }
+
+ void PG::on_change(ceph::os::Transaction &t) {
+- logger().debug("{}, {}", __func__, *this);
++ logger().debug("{}, {}", __func__, fmt::streamed(*this));
+ for (auto& obc : obc_set_accessing) {
+ obc.interrupt(::crimson::common::actingset_changed(is_primary()));
+ }
+--- ceph-17.2.3/src/crimson/osd/pg_backend.cc.orig 2022-07-28 23:52:12.000000000 +0200
++++ ceph-17.2.3/src/crimson/osd/pg_backend.cc 2022-09-12 19:43:42.529108520 +0200
+@@ -16,6 +16,7 @@
+ #include "os/Transaction.h"
+ #include "common/Checksummer.h"
+ #include "common/Clock.h"
++#include "common/hobject_fmt.h"
+
+ #include "crimson/common/exception.h"
+ #include "crimson/os/futurized_collection.h"
+--- ceph-17.2.3/src/crimson/osd/pg_interval_interrupt_condition.cc.orig 2022-07-28 23:52:12.000000000 +0200
++++ ceph-17.2.3/src/crimson/osd/pg_interval_interrupt_condition.cc 2022-09-14 16:25:56.740431797 +0200
+@@ -20,14 +20,14 @@ bool IOInterruptCondition::new_interval_
+ bool ret = e < pg->get_interval_start_epoch();
+ if (ret)
+ ::crimson::get_logger(ceph_subsys_osd).debug(
+- "{} new interval, should interrupt, e{}", *pg, e);
++ "{} new interval, should interrupt, e{}", fmt::streamed(*pg), e);
+ return ret;
+ }
+
+ bool IOInterruptCondition::is_stopping() {
+ if (pg->stopping)
+ ::crimson::get_logger(ceph_subsys_osd).debug(
+- "{} shutting down, should interrupt", *pg);
++ "{} shutting down, should interrupt", fmt::streamed(*pg));
+ return pg->stopping;
+ }
+
+--- ceph-17.2.3/src/crimson/osd/pg_map.cc.orig 2022-07-28 23:52:12.000000000 +0200
++++ ceph-17.2.3/src/crimson/osd/pg_map.cc 2022-09-14 16:26:00.380623198 +0200
+@@ -5,6 +5,7 @@
+
+ #include "crimson/osd/pg.h"
+ #include "common/Formatter.h"
++#include "osd/osd_types_fmt.h"
+
+ namespace {
+ seastar::logger& logger() {
+--- ceph-17.2.3/src/crimson/osd/pg_recovery.cc.orig 2022-07-28 23:52:12.000000000 +0200
++++ ceph-17.2.3/src/crimson/osd/pg_recovery.cc 2022-09-13 18:51:33.867800178 +0200
+@@ -13,6 +13,7 @@
+ #include "crimson/osd/pg_recovery.h"
+
+ #include "osd/osd_types.h"
++#include "osd/osd_types_fmt.h"
+ #include "osd/PeeringState.h"
+
+ namespace {
+@@ -109,8 +110,8 @@ size_t PGRecovery::start_primary_recover
+
+ logger().info("{} recovering {} in pg {}, missing {}", __func__,
+ pg->get_recovery_backend()->total_recovering(),
+- *static_cast<crimson::osd::PG*>(pg),
+- missing);
++ fmt::streamed(*static_cast<crimson::osd::PG*>(pg)),
++ fmt::streamed(missing));
+
+ unsigned started = 0;
+ int skipped = 0;
+@@ -187,7 +188,7 @@ size_t PGRecovery::start_replica_recover
+ logger().debug("{}: peer osd.{} missing {} objects", __func__,
+ peer, pm.num_missing());
+ logger().trace("{}: peer osd.{} missing {}", __func__,
+- peer, pm.get_items());
++ peer, fmt::streamed(pm.get_items()));
+
+ // recover oldest first
+ for (auto p = pm.get_rmissing().begin();
+--- ceph-17.2.3/src/crimson/osd/recovery_backend.cc.orig 2022-07-28 23:52:12.000000000 +0200
++++ ceph-17.2.3/src/crimson/osd/recovery_backend.cc 2022-09-13 21:22:46.876223766 +0200
+@@ -10,6 +10,7 @@
+
+ #include "messages/MOSDFastDispatchOp.h"
+ #include "osd/osd_types.h"
++#include "osd/osd_types_fmt.h"
+
+ namespace {
+ seastar::logger& logger() {
+@@ -126,7 +127,7 @@ RecoveryBackend::handle_backfill(
+ {
+ logger().debug("{}", __func__);
+ if (pg.old_peering_msg(m.map_epoch, m.query_epoch)) {
+- logger().debug("{}: discarding {}", __func__, m);
++ logger().debug("{}: discarding {}", __func__, fmt::streamed(m));
+ return seastar::now();
+ }
+ switch (m.op) {
+@@ -147,10 +148,10 @@ RecoveryBackend::interruptible_future<>
+ RecoveryBackend::handle_backfill_remove(
+ MOSDPGBackfillRemove& m)
+ {
+- logger().debug("{} m.ls={}", __func__, m.ls);
++ logger().debug("{} m.ls={}", __func__, fmt::streamed(m.ls));
+ assert(m.get_type() == MSG_OSD_PG_BACKFILL_REMOVE);
+ if (pg.can_discard_replica_op(m)) {
+- logger().debug("{}: discarding {}", __func__, m);
++ logger().debug("{}: discarding {}", __func__, fmt::streamed(m));
+ return seastar::now();
+ }
+ ObjectStore::Transaction t;
+@@ -285,7 +286,7 @@ RecoveryBackend::handle_scan(
+ {
+ logger().debug("{}", __func__);
+ if (pg.old_peering_msg(m.map_epoch, m.query_epoch)) {
+- logger().debug("{}: discarding {}", __func__, m);
++ logger().debug("{}: discarding {}", __func__, fmt::streamed(m));
+ return seastar::now();
+ }
+ switch (m.op) {
+--- ceph-17.2.3/src/crimson/osd/replicated_backend.cc.orig 2022-07-28 23:52:12.000000000 +0200
++++ ceph-17.2.3/src/crimson/osd/replicated_backend.cc 2022-09-12 19:49:54.678938412 +0200
+@@ -10,6 +10,7 @@
+ #include "crimson/os/futurized_store.h"
+ #include "crimson/osd/shard_services.h"
+ #include "osd/PeeringState.h"
++#include "osd/osd_types_fmt.h"
+
+ namespace {
+ seastar::logger& logger() {
+@@ -121,7 +122,7 @@ void ReplicatedBackend::got_rep_op_reply
+ {
+ auto found = pending_trans.find(reply.get_tid());
+ if (found == pending_trans.end()) {
+- logger().warn("{}: no matched pending rep op: {}", __func__, reply);
++ logger().warn("{}: no matched pending rep op: {}", __func__, fmt::streamed(reply));
+ return;
+ }
+ auto& peers = found->second;
+--- ceph-17.2.3/src/crimson/osd/replicated_recovery_backend.cc.orig 2022-07-28 23:52:12.000000000 +0200
++++ ceph-17.2.3/src/crimson/osd/replicated_recovery_backend.cc 2022-09-14 16:26:03.774134962 +0200
+@@ -2,6 +2,7 @@
+ // vim: ts=8 sw=2 smarttab expandtab
+
+ #include <fmt/format.h>
++#include <fmt/os.h>
+ #include <fmt/ostream.h>
+ #include <seastar/core/future.hh>
+ #include <seastar/core/do_with.hh>
+@@ -10,6 +11,8 @@
+ #include "crimson/osd/pg_backend.h"
+ #include "replicated_recovery_backend.h"
+
++#include "common/hobject_fmt.h"
++#include "osd/osd_types_fmt.h"
+ #include "msg/Message.h"
+
+ namespace {
+@@ -18,6 +21,9 @@ namespace {
+ }
+ }
+
++template <>
++struct fmt::formatter<MOSDPGPush> : ostream_formatter {};
++
+ using std::less;
+ using std::map;
+ using std::string;
+@@ -170,7 +176,7 @@ RecoveryBackend::interruptible_future<>
+ ReplicatedRecoveryBackend::handle_recovery_delete(
+ Ref<MOSDPGRecoveryDelete> m)
+ {
+- logger().debug("{}: {}", __func__, *m);
++ logger().debug("{}: {}", __func__, fmt::streamed(*m));
+
+ auto& p = m->objects.front(); //TODO: only one delete per message for now.
+ return local_recover_delete(p.first, p.second, pg.get_osdmap_epoch())
+@@ -465,7 +471,7 @@ ReplicatedRecoveryBackend::read_metadata
+ for (auto&& [key, val] : attrs) {
+ push_op->attrset.emplace(std::move(key), std::move(val));
+ }
+- logger().debug("read_metadata_for_push_op: {}", push_op->attrset[OI_ATTR]);
++ logger().debug("read_metadata_for_push_op: {}", fmt::streamed(push_op->attrset[OI_ATTR]));
+ object_info_t oi;
+ oi.decode_no_oid(push_op->attrset[OI_ATTR]);
+ new_progress.first = false;
+@@ -593,9 +599,9 @@ ReplicatedRecoveryBackend::get_shards_to
+ RecoveryBackend::interruptible_future<>
+ ReplicatedRecoveryBackend::handle_pull(Ref<MOSDPGPull> m)
+ {
+- logger().debug("{}: {}", __func__, *m);
++ logger().debug("{}: {}", __func__, fmt::streamed(*m));
+ if (pg.can_discard_replica_op(*m)) {
+- logger().debug("{}: discarding {}", __func__, *m);
++ logger().debug("{}: discarding {}", __func__, fmt::streamed(*m));
+ return seastar::now();
+ }
+ return seastar::do_with(m->take_pulls(), [this, from=m->from](auto& pulls) {
+@@ -643,7 +649,7 @@ ReplicatedRecoveryBackend::_handle_pull_
+ ceph::os::Transaction* t)
+ {
+ logger().debug("handle_pull_response {} {} data.size() is {} data_included: {}",
+- pop.recovery_info, pop.after_progress, pop.data.length(), pop.data_included);
++ fmt::streamed(pop.recovery_info), fmt::streamed(pop.after_progress), pop.data.length(), pop.data_included);
+
+ const hobject_t &hoid = pop.soid;
+ auto& recovery_waiter = recovering.at(hoid);
+@@ -674,7 +680,7 @@ ReplicatedRecoveryBackend::_handle_pull_
+ const bool first = pi.recovery_progress.first;
+ pi.recovery_progress = pop.after_progress;
+ logger().debug("new recovery_info {}, new progress {}",
+- pi.recovery_info, pi.recovery_progress);
++ fmt::streamed(pi.recovery_info), fmt::streamed(pi.recovery_progress));
+ interval_set<uint64_t> data_zeros;
+ {
+ uint64_t offset = pop.before_progress.data_recovered_to;
+@@ -888,7 +894,7 @@ RecoveryBackend::interruptible_future<>
+ ReplicatedRecoveryBackend::handle_push_reply(
+ Ref<MOSDPGPushReply> m)
+ {
+- logger().debug("{}: {}", __func__, *m);
++ logger().debug("{}: {}", __func__, fmt::streamed(*m));
+ auto from = m->from;
+ auto& push_reply = m->replies[0]; //TODO: only one reply per message
+
+--- ceph-17.2.3/src/crimson/osd/shard_services.cc.orig 2022-07-28 23:52:12.000000000 +0200
++++ ceph-17.2.3/src/crimson/osd/shard_services.cc 2022-09-12 18:10:09.584797181 +0200
+@@ -8,6 +8,7 @@
+ #include "messages/MOSDPGTemp.h"
+
+ #include "osd/osd_perf_counters.h"
++#include "osd/osd_types_fmt.h"
+ #include "osd/PeeringState.h"
+ #include "crimson/common/config_proxy.h"
+ #include "crimson/mgr/client.h"
+@@ -191,7 +192,7 @@ seastar::future<> ShardServices::send_pg
+ {
+ if (pg_temp_wanted.empty())
+ return seastar::now();
+- logger().debug("{}: {}", __func__, pg_temp_wanted);
++ logger().debug("{}: {}", __func__, fmt::streamed(pg_temp_wanted));
+ MURef<MOSDPGTemp> ms[2] = {nullptr, nullptr};
+ for (auto& [pgid, pg_temp] : pg_temp_wanted) {
+ auto& m = ms[pg_temp.forced];
+--- ceph-17.2.3/src/crimson/osd/watch.cc.orig 2022-07-28 23:52:12.000000000 +0200
++++ ceph-17.2.3/src/crimson/osd/watch.cc 2022-09-14 16:25:52.640216209 +0200
+@@ -10,6 +10,7 @@
+ #include "crimson/osd/osd_operations/internal_client_request.h"
+
+ #include "messages/MWatchNotify.h"
++#include "osd/osd_types_fmt.h"
+
+
+ namespace {
+@@ -257,7 +258,7 @@ seastar::future<> Notify::send_completio
+ {
+ logger().info("{} -- {} in progress watchers, timedout watchers {}",
+ __func__, watchers.size(), timedout_watchers.size());
+- logger().debug("{} sending notify replies: {}", __func__, notify_replies);
++ logger().debug("{} sending notify replies: {}", __func__, fmt::streamed(notify_replies));
+
+ ceph::bufferlist empty;
+ auto reply = crimson::make_message<MWatchNotify>(
+--- ceph-17.2.3/src/crimson/osd/osd_operations/client_request.h.orig 2022-07-28 23:52:12.000000000 +0200
++++ ceph-17.2.3/src/crimson/osd/osd_operations/client_request.h 2022-09-12 21:54:55.796154929 +0200
+@@ -98,3 +98,6 @@ private:
+ };
+
+ }
++
++template <>
++struct fmt::formatter<crimson::osd::ClientRequest> : ostream_formatter {};
+--- ceph-17.2.3/src/crimson/osd/osd_operations/background_recovery.cc.orig 2022-07-28 23:52:12.000000000 +0200
++++ ceph-17.2.3/src/crimson/osd/osd_operations/background_recovery.cc 2022-09-13 17:40:57.542629721 +0200
+@@ -49,7 +49,7 @@ void BackgroundRecovery::dump_detail(For
+
+ seastar::future<> BackgroundRecovery::start()
+ {
+- logger().debug("{}: start", *this);
++ logger().debug("{}: start", fmt::streamed(*this));
+
+ IRef ref = this;
+ auto maybe_delay = seastar::now();
+@@ -67,7 +67,7 @@ seastar::future<> BackgroundRecovery::st
+ }, pg);
+ }).handle_exception_type([ref, this](const std::system_error& err) {
+ if (err.code() == std::make_error_code(std::errc::interrupted)) {
+- logger().debug("{} recovery interruped: {}", *pg, err.what());
++ logger().debug("{} recovery interruped: {}", fmt::streamed(*pg), err.what());
+ return seastar::now();
+ }
+ return seastar::make_exception_future<>(err);
+@@ -78,7 +78,7 @@ seastar::future<> BackgroundRecovery::st
+ UrgentRecovery::interruptible_future<bool>
+ UrgentRecovery::do_recovery()
+ {
+- logger().debug("{}: {}", __func__, *this);
++ logger().debug("{}: {}", __func__, fmt::streamed(*this));
+ if (!pg->has_reset_since(epoch_started)) {
+ return with_blocking_future_interruptible<interruptor::condition>(
+ pg->get_recovery_handler()->recover_missing(soid, need)
+--- ceph-17.2.3/src/crimson/osd/osd_operations/client_request.cc.orig 2022-07-28 23:52:12.000000000 +0200
++++ ceph-17.2.3/src/crimson/osd/osd_operations/client_request.cc 2022-09-12 22:14:51.672228672 +0200
+@@ -1,6 +1,7 @@
+ // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:nil -*-
+ // vim: ts=8 sw=2 smarttab expandtab
+
++#include <fmt/os.h>
+ #include <seastar/core/future.hh>
+
+ #include "messages/MOSDOp.h"
+--- ceph-17.2.3/src/crimson/osd/osd_operations/client_request_common.cc.orig 2022-07-28 23:52:12.000000000 +0200
++++ ceph-17.2.3/src/crimson/osd/osd_operations/client_request_common.cc 2022-09-12 22:19:24.919860123 +0200
+@@ -1,6 +1,7 @@
+ // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:nil -*-
+ // vim: ts=8 sw=2 smarttab expandtab
+
++#include "common/hobject_fmt.h"
+ #include "crimson/osd/osd_operations/client_request_common.h"
+ #include "crimson/osd/pg.h"
+
+@@ -43,10 +44,10 @@ bool CommonClientRequest::should_abort_r
+ std::rethrow_exception(eptr);
+ } catch(::crimson::common::actingset_changed& e) {
+ if (e.is_primary()) {
+- logger().debug("{} {} operation restart, acting set changed", __func__, op);
++ logger().debug("{} {} operation restart, acting set changed", __func__, fmt::streamed(op));
+ return false;
+ } else {
+- logger().debug("{} {} operation abort, up primary changed", __func__, op);
++ logger().debug("{} {} operation abort, up primary changed", __func__, fmt::streamed(op));
+ return true;
+ }
+ }
+@@ -54,7 +55,7 @@ bool CommonClientRequest::should_abort_r
+ assert(*eptr.__cxa_exception_type() ==
+ typeid(crimson::common::system_shutdown_exception));
+ crimson::get_logger(ceph_subsys_osd).debug(
+- "{} {} operation skipped, system shutdown", __func__, op);
++ "{} {} operation skipped, system shutdown", __func__, fmt::streamed(op));
+ return true;
+ }
+ }
+--- ceph-17.2.3/src/crimson/osd/osd_operations/compound_peering_request.cc.orig 2022-07-28 23:52:12.000000000 +0200
++++ ceph-17.2.3/src/crimson/osd/osd_operations/compound_peering_request.cc 2022-09-13 16:37:59.084922640 +0200
+@@ -4,6 +4,7 @@
+ #include <seastar/core/future.hh>
+
+ #include "osd/PeeringState.h"
++#include "osd/osd_types_fmt.h"
+
+ #include "messages/MOSDPGCreate2.h"
+
+@@ -44,7 +45,7 @@ public:
+
+ PeeringEvent::interruptible_future<>
+ complete_rctx(Ref<crimson::osd::PG> pg) final {
+- logger().debug("{}: submitting ctx transaction", *this);
++ logger().debug("{}: submitting ctx transaction", fmt::streamed(*this));
+ state->ctx.accept_buffered_messages(ctx);
+ state = {};
+ if (!pg) {
+@@ -73,14 +74,14 @@ std::vector<crimson::OperationRef> handl
+ "{}: {} e{} @{} "
+ "history {} pi {}",
+ __func__, pgid, created, created_stamp,
+- history, pi);
++ history, fmt::streamed(pi));
+ if (!pi.empty() &&
+ m->epoch < pi.get_bounds().second) {
+ logger().error(
+ "got pg_create on {} epoch {} "
+ "unmatched past_intervals {} (history {})",
+ pgid, m->epoch,
+- pi, history);
++ fmt::streamed(pi), history);
+ } else {
+ auto op = osd.get_shard_services().start_operation<PeeringSubEvent>(
+ state,
+@@ -141,7 +142,7 @@ void CompoundPeeringRequest::dump_detail
+
+ seastar::future<> CompoundPeeringRequest::start()
+ {
+- logger().info("{}: starting", *this);
++ logger().info("{}: starting", fmt::streamed(*this));
+ auto state = seastar::make_lw_shared<compound_state>();
+ auto blocker = std::make_unique<SubOpBlocker>(
+ [&] {
+@@ -154,16 +155,16 @@ seastar::future<> CompoundPeeringRequest
+ }());
+
+ IRef ref = this;
+- logger().info("{}: about to fork future", *this);
++ logger().info("{}: about to fork future", fmt::streamed(*this));
+ return crimson::common::handle_system_shutdown(
+ [this, ref, blocker=std::move(blocker), state]() mutable {
+ return with_blocking_future(
+ blocker->make_blocking_future(state->promise.get_future())
+ ).then([this, blocker=std::move(blocker)](auto &&ctx) {
+- logger().info("{}: sub events complete", *this);
++ logger().info("{}: sub events complete", fmt::streamed(*this));
+ return osd.get_shard_services().dispatch_context_messages(std::move(ctx));
+ }).then([this, ref=std::move(ref)] {
+- logger().info("{}: complete", *this);
++ logger().info("{}: complete", fmt::streamed(*this));
+ });
+ });