ceph/0026-src-osd-scrubber-scrub_backend.cc.patch

--- 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()) {