Merge pull request ceph#65859 from ronen-fr/wip-rf-minchunk

osd/scrub: do not reduce min chunk on preemption

Reviewed-by: Samuel Just <[email protected]>

Author: ronen-fr

src/common/options/osd.yaml.in

@@ -379,8 +379,9 @@ options:
   type: int
   level: advanced
   desc: Minimum number of objects to deep-scrub in a single chunk
-  fmt_desc: The minimal number of object store chunks to scrub during single operation.
-    Ceph blocks writes to single chunk during scrub.
+  fmt_desc: The minimum number of objects to scrub during single operation. Also
+    serves as a minimal chunk size even after scrubbing is preempted by client
+    operations and the effective chunk size is halved.
   default: 5
   see_also:
   - osd_scrub_chunk_max
@@ -1559,7 +1560,7 @@ options:
   type: int
   level: advanced
   default: 512
-  fmt_desc: The maximum number of objects per backfill scan.p
+  fmt_desc: The maximum number of objects per backfill scan.
   with_legacy: true
 - name: osd_extblkdev_plugins
   type: str

src/osd/osd_perf_counters.cc

@@ -407,6 +407,14 @@ PerfCounters *build_osd_logger(CephContext *cct) {
       l_osd_scrub_rppool_failed_elapsed,
       "failed_scrubs_replicated_elapsed",
       "time to scrub failure replicated");
+  osd_plb.add_u64_counter(
+      l_osd_scrub_rppool_write_intersects,
+      "scrub_replicated_io_intersects",
+      "client write op intersects chunk range");
+  osd_plb.add_u64_counter(
+      l_osd_scrub_rppool_write_blocked,
+      "scrub_replicated_io_blocked",
+      "write op did not preempt the scrub");
 
   // the replica reservation process - replicated pool
   osd_plb.add_u64_counter(
@@ -456,6 +464,14 @@ PerfCounters *build_osd_logger(CephContext *cct) {
   osd_plb.add_time_avg(
       l_osd_scrub_ec_failed_elapsed, "failed_scrubs_ec_elapsed",
       "time to scrub failure ec");
+  osd_plb.add_u64_counter(
+      l_osd_scrub_ec_write_intersects,
+      "scrub_ec_io_intersects",
+      "client write op intersects chunk range");
+  osd_plb.add_u64_counter(
+      l_osd_scrub_ec_write_blocked,
+      "scrub_ec_io_blocked",
+      "write op did not preempt the scrub");
 
   // the secondaries reservation process - EC
   osd_plb.add_u64_counter(

src/osd/osd_perf_counters.h

@@ -170,6 +170,8 @@ enum osd_counter_idx_t {
   l_osd_scrub_rppool_successful_elapsed, ///< time to complete a successful scrub
   l_osd_scrub_rppool_failed, ///< failed scrubs count
   l_osd_scrub_rppool_failed_elapsed, ///< time from start to failure
+  l_osd_scrub_rppool_write_intersects, ///< client write op intersects chunk range
+  l_osd_scrub_rppool_write_blocked, ///< write op did not preempt the scrub
 
   // ----   scrub reservation process - replicated pools
 
@@ -196,6 +198,8 @@ enum osd_counter_idx_t {
   l_osd_scrub_ec_successful_elapsed, ///< time to complete a successful scrub
   l_osd_scrub_ec_failed, ///< failed scrubs count
   l_osd_scrub_ec_failed_elapsed, ///< time from start to failure
+  l_osd_scrub_ec_write_intersects, ///< client write op intersects chunk range
+  l_osd_scrub_ec_write_blocked, ///< write op did not preempt the scrub
 
   // ----   scrub reservation process - EC
 

src/osd/scrubber/pg_scrubber.cc

@@ -911,8 +911,8 @@ std::optional<uint64_t> PgScrubber::select_range()
   const int max_from_conf = static_cast<int>(size_from_conf(
       m_is_deep, conf, osd_scrub_chunk_max, osd_shallow_scrub_chunk_max));
 
+  const int min_chunk_sz = std::max(3, min_from_conf);
   const int divisor = static_cast<int>(preemption_data.chunk_divisor());
-  const int min_chunk_sz = std::max(3, min_from_conf / divisor);
   const int max_chunk_sz = std::max(min_chunk_sz, max_from_conf / divisor);
 
   dout(10) << fmt::format(
@@ -1020,7 +1020,8 @@ bool PgScrubber::write_blocked_by_scrub(const hobject_t& soid)
     return false;
   }
 
-  get_labeled_counters()->inc(scrbcnt_write_blocked);
+  const auto& unlabeled_cntrs_idx = get_unlabeled_counters();
+  get_osd_perf_counters()->inc(unlabeled_cntrs_idx.write_intersects);
   dout(20) << __func__ << " " << soid << " can preempt? "
 	   << preemption_data.is_preemptable() << " already preempted? "
 	   << preemption_data.was_preempted() << dendl;
@@ -1042,6 +1043,10 @@ bool PgScrubber::write_blocked_by_scrub(const hobject_t& soid)
 
     return false;
   }
+
+  get_osd_perf_counters()->inc(unlabeled_cntrs_idx.write_blocked);
+  // to be removed in version 'Umbrella':
+  get_labeled_counters()->inc(scrbcnt_write_blocked);
   return true;
 }
 

src/osd/scrubber/pg_scrubber.h

@@ -150,6 +150,8 @@ static inline constexpr ScrubCounterSet io_counters_replicated{
   .successful_elapsed = l_osd_scrub_rppool_successful_elapsed,
   .failed_cnt = l_osd_scrub_rppool_failed,
   .failed_elapsed = l_osd_scrub_rppool_failed_elapsed,
+  .write_intersects = l_osd_scrub_rppool_write_intersects,
+  .write_blocked = l_osd_scrub_rppool_write_blocked,
   // replica-reservation-related:
   .rsv_successful_cnt = l_osd_scrub_rppool_reserv_success,
   .rsv_successful_elapsed = l_osd_scrub_rppool_reserv_successful_elapsed,
@@ -175,6 +177,8 @@ static inline constexpr ScrubCounterSet io_counters_ec{
   .successful_elapsed = l_osd_scrub_ec_successful_elapsed,
   .failed_cnt = l_osd_scrub_ec_failed,
   .failed_elapsed = l_osd_scrub_ec_failed_elapsed,
+  .write_intersects = l_osd_scrub_ec_write_intersects,
+  .write_blocked = l_osd_scrub_ec_write_blocked,
   // replica-reservation-related:
   .rsv_successful_cnt = l_osd_scrub_ec_reserv_success,
   .rsv_successful_elapsed = l_osd_scrub_ec_reserv_successful_elapsed,

src/osd/scrubber_common.h

@@ -323,6 +323,8 @@ struct ScrubCounterSet {
   osd_counter_idx_t successful_elapsed; ///< time to complete a successful scrub
   osd_counter_idx_t failed_cnt; ///< failed scrubs count
   osd_counter_idx_t failed_elapsed; ///< time from start to failure
+  osd_counter_idx_t write_intersects; ///< client write op intersects chunk range
+  osd_counter_idx_t write_blocked; ///< write op did not preempt the scrub
   // reservation process related:
   osd_counter_idx_t rsv_successful_cnt; ///< completed reservation processes
   osd_counter_idx_t rsv_successful_elapsed; ///< time to all-reserved