--- ceph-18.0.0-2148-g9754cafc/src/osd/scrubber/scrub_backend.cc.orig	2023-02-08 16:01:53.800709761 -0500

+++ ceph-18.0.0-2148-g9754cafc/src/osd/scrubber/scrub_backend.cc	2023-02-11 05:06:14.954254050 -0500

@@ -507,11 +507,11 @@

     }

   }

-  dout(10) << fmt::format("{}: selecting osd {} for obj {} with oi {}",

+  dout(10) << fmt::format("{}: selecting osd {} for obj {} with oi {:p}",

                           __func__,

                           ret_auth.auth_shard,

                           ho,

-                          ret_auth.auth_oi)

+                          (void*)&ret_auth.auth_oi)

            << dendl;

   return ret_auth;

@@ -1171,23 +1171,23 @@

   if (auth.digest_present && candidate.digest_present &&

       auth.digest != candidate.digest) {

-    format_to(std::back_inserter(out),

-              "data_digest {:#x} != data_digest {:#x} from shard {}",

-              candidate.digest,

-              auth.digest,

-              auth_shard);

+    fmt::format_to(std::back_inserter(out),

+                   "data_digest {:#x} != data_digest {:#x} from shard {}",

+                   candidate.digest,

+                   auth.digest,

+                   auth_shard);

     error = true;

     obj_result.set_data_digest_mismatch();

   }

   if (auth.omap_digest_present && candidate.omap_digest_present &&

       auth.omap_digest != candidate.omap_digest) {

-    format_to(std::back_inserter(out),

-              "{}omap_digest {:#x} != omap_digest {:#x} from shard {}",

-              sep(error),

-              candidate.omap_digest,

-              auth.omap_digest,

-              auth_shard);

+    fmt::format_to(std::back_inserter(out),

+                   "{}omap_digest {:#x} != omap_digest {:#x} from shard {}",

+                   sep(error),

+                   candidate.omap_digest,

+                   auth.omap_digest,

+                   auth_shard);

     obj_result.set_omap_digest_mismatch();

   }

@@ -1195,24 +1195,24 @@

   if (m_is_replicated) {

     if (auth_oi.is_data_digest() && candidate.digest_present &&

         auth_oi.data_digest != candidate.digest) {

-      format_to(std::back_inserter(out),

-                "{}data_digest {:#x} != data_digest {:#x} from auth oi {}",

-                sep(error),

-                candidate.digest,

-                auth_oi.data_digest,

-                auth_oi);

+      fmt::format_to(std::back_inserter(out),

+                     "{}data_digest {:#x} != data_digest {:#x} from auth oi {:p}",

+                     sep(error),

+                     candidate.digest,

+                     auth_oi.data_digest,

+                     (void*)&auth_oi);

       shard_result.set_data_digest_mismatch_info();

     }

     // for replicated:

     if (auth_oi.is_omap_digest() && candidate.omap_digest_present &&

         auth_oi.omap_digest != candidate.omap_digest) {

-      format_to(std::back_inserter(out),

-                "{}omap_digest {:#x} != omap_digest {:#x} from auth oi {}",

-                sep(error),

-                candidate.omap_digest,

-                auth_oi.omap_digest,

-                auth_oi);

+      fmt::format_to(std::back_inserter(out),

+                     "{}omap_digest {:#x} != omap_digest {:#x} from auth oi {:p}",

+                     sep(error),

+                     candidate.omap_digest,

+                     auth_oi.omap_digest,

+                     (void*)&auth_oi);

       shard_result.set_omap_digest_mismatch_info();

     }

   }

@@ -1241,7 +1241,7 @@

     auth_bl.push_back(auth_attr->second);

     if (!can_bl.contents_equal(auth_bl)) {

-      format_to(std::back_inserter(out), "{}object info inconsistent ", sep(error));

+      fmt::format_to(std::back_inserter(out), "{}object info inconsistent ", sep(error));

       obj_result.set_object_info_inconsistency();

     }

   }

@@ -1261,7 +1261,7 @@

       auth_bl.push_back(auth_attr->second);

       if (!can_bl.contents_equal(auth_bl)) {

-        format_to(std::back_inserter(out), "{}snapset inconsistent ", sep(error));

+        fmt::format_to(std::back_inserter(out), "{}snapset inconsistent ", sep(error));

         obj_result.set_snapset_inconsistency();

       }

     }

@@ -1284,7 +1284,7 @@

       auth_bl.push_back(auth_hi->second);

       if (!can_bl.contents_equal(auth_bl)) {

-        format_to(std::back_inserter(out), "{}hinfo inconsistent ", sep(error));

+        fmt::format_to(std::back_inserter(out), "{}hinfo inconsistent ", sep(error));

         obj_result.set_hinfo_inconsistency();

       }

     }

@@ -1296,22 +1296,22 @@

   uint64_t oi_size = logical_to_ondisk_size(auth_oi.size);

   if (oi_size != candidate.size) {

-    format_to(std::back_inserter(out),

-              "{}size {} != size {} from auth oi {}",

-              sep(error),

-              candidate.size,

-              oi_size,

-              auth_oi);

+    fmt::format_to(std::back_inserter(out),

+                   "{}size {} != size {} from auth oi {:p}",

+                   sep(error),

+                   candidate.size,

+                   oi_size,

+                   (void*)&auth_oi);

     shard_result.set_size_mismatch_info();

   }

   if (auth.size != candidate.size) {

-    format_to(std::back_inserter(out),

-              "{}size {} != size {} from shard {}",

-              sep(error),

-              candidate.size,

-              auth.size,

-              auth_shard);

+    fmt::format_to(std::back_inserter(out),

+                   "{}size {} != size {} from shard {}",

+                   sep(error),

+                   candidate.size,

+                   auth.size,

+                   auth_shard);

     obj_result.set_size_mismatch();

   }

@@ -1320,11 +1320,11 @@

   if (candidate.size > m_conf->osd_max_object_size &&

       !obj_result.has_size_too_large()) {

-    format_to(std::back_inserter(out),

-              "{}size {} > {} is too large",

-              sep(error),

-              candidate.size,

-              m_conf->osd_max_object_size);

+    fmt::format_to(std::back_inserter(out),

+                   "{}size {} > {} is too large",

+                   sep(error),

+                   candidate.size,

+                   m_conf->osd_max_object_size);

     obj_result.set_size_too_large();

   }

@@ -1340,10 +1340,10 @@

     auto cand = candidate.attrs.find(k);

     if (cand == candidate.attrs.end()) {

-      format_to(std::back_inserter(out), "{}attr name mismatch '{}'", sep(error), k);

+      fmt::format_to(std::back_inserter(out), "{}attr name mismatch '{}'", sep(error), k);

       obj_result.set_attr_name_mismatch();

     } else if (cand->second.cmp(v)) {

-      format_to(std::back_inserter(out), "{}attr value mismatch '{}'", sep(error), k);

+      fmt::format_to(std::back_inserter(out), "{}attr value mismatch '{}'", sep(error), k);

       obj_result.set_attr_value_mismatch();

     }

   }

@@ -1356,7 +1356,7 @@

     auto in_auth = auth.attrs.find(k);

     if (in_auth == auth.attrs.end()) {

-      format_to(std::back_inserter(out), "{}attr name mismatch '{}'", sep(error), k);

+      fmt::format_to(std::back_inserter(out), "{}attr name mismatch '{}'", sep(error), k);

       obj_result.set_attr_name_mismatch();

     }

   }

@@ -1823,8 +1823,7 @@

   SnapMapReaderI& snaps_getter)

 {

   using result_t = Scrub::SnapMapReaderI::result_t;

-  dout(15) << fmt::format("{}: obj:{} snapset:{}", __func__, hoid, snapset)

-	   << dendl;

+  // dout(15) << fmt::format("{}: obj:{} snapset:{}", __func__, hoid, snapset) << dendl;

   auto p = snapset.clone_snaps.find(hoid.snap);

   if (p == snapset.clone_snaps.end()) {