osd/scrub: fix initiation path of operator-commanded scrubs

Signed-off-by: Ronen Friedman <rfriedma@redhat.com>

diff --git a/src/osd/scrubber/osd_scrub.cc b/src/osd/scrubber/osd_scrub.cc
index e2e1aa34661b87c5f5ccc124cf393a37c914d259..783973f78f9f6db360802d2bd0f86cb0ef463738 100644 (file)
--- a/src/osd/scrubber/osd_scrub.cc
+++ b/src/osd/scrubber/osd_scrub.cc
@@ -431,6 +431,11 @@ void OsdScrub::enqueue_target(const Scrub::SchedTarget& trgt)
   m_queue.enqueue_target(trgt);
 }
 
+void OsdScrub::dequeue_target(spg_t pgid, scrub_level_t s_or_d)
+{
+  m_queue.dequeue_target(pgid, s_or_d);
+}
+
 void OsdScrub::remove_from_osd_queue(spg_t pgid)
 {
   m_queue.remove_from_osd_queue(pgid);

diff --git a/src/osd/scrubber/osd_scrub.h b/src/osd/scrubber/osd_scrub.h
index 1f1c62bc8dab7ac9befc744d40eab43bededd4fc..481f53581be2349cf8288657f87987a6e61a94f6 100644 (file)
--- a/src/osd/scrubber/osd_scrub.h
+++ b/src/osd/scrubber/osd_scrub.h
@@ -88,6 +88,11 @@ class OsdScrub {
    */
   void enqueue_target(const Scrub::SchedTarget& trgt);
 
+  /**
+   * remove the specified scheduling target from the OSD scrub queue
+   */
+  void dequeue_target(spg_t pgid, scrub_level_t s_or_d);
+
   /**
    * remove the pg from set of PGs to be scanned for scrubbing.
    * To be used if we are no longer the PG's primary, or if the PG is removed.

diff --git a/src/osd/scrubber/osd_scrub_sched.cc b/src/osd/scrubber/osd_scrub_sched.cc
index 8784438ce633670cc4cff07d04f734daa5505c81..56fbb995ef03138c935942acb2cc0c919fba6044 100644 (file)
--- a/src/osd/scrubber/osd_scrub_sched.cc
+++ b/src/osd/scrubber/osd_scrub_sched.cc
@@ -73,6 +73,14 @@ void ScrubQueue::enqueue_target(const Scrub::SchedTarget& trgt)
   to_scrub.enqueue(trgt.queued_element());
 }
 
+
+void ScrubQueue::dequeue_target(spg_t pgid, scrub_level_t s_or_d)
+{
+  std::unique_lock lck{jobs_lock};
+  remove_entry_unlocked(pgid, s_or_d);
+}
+
+
 std::optional<Scrub::SchedEntry> ScrubQueue::pop_ready_entry(
     OSDRestrictions restrictions,  // note: 4B in size! (thus - copy)
     utime_t time_now)

diff --git a/src/osd/scrubber/osd_scrub_sched.h b/src/osd/scrubber/osd_scrub_sched.h
index 5f8aaec3a8ce78574e74fdb71d362dc66cf3cea8..fa0fa542dfcfe190d5d63d9b6ed72550b173a073 100644 (file)
--- a/src/osd/scrubber/osd_scrub_sched.h
+++ b/src/osd/scrubber/osd_scrub_sched.h
@@ -189,6 +189,8 @@ class ScrubQueue {
    */
   void enqueue_target(const Scrub::SchedTarget& trgt);
 
+  void dequeue_target(spg_t pgid, scrub_level_t s_or_d);
+
   std::ostream& gen_prefix(std::ostream& out, std::string_view fn) const;
 
  public:

diff --git a/src/osd/scrubber/pg_scrubber.cc b/src/osd/scrubber/pg_scrubber.cc
index 8546af02cd2cadc522af0079fa1f7e7a0105bfb8..f31954df3ebb7befa14166f5d8a3d157fbd6120e 100644 (file)
--- a/src/osd/scrubber/pg_scrubber.cc
+++ b/src/osd/scrubber/pg_scrubber.cc
@@ -663,8 +663,10 @@ scrub_level_t PgScrubber::scrub_requested(
     scrub_type_t scrub_type,
     requested_scrub_t& req_flags)
 {
-  const bool deep_requested = (scrub_level == scrub_level_t::deep) ||
-                             (scrub_type == scrub_type_t::do_repair);
+  const bool repair_requested = (scrub_type == scrub_type_t::do_repair);
+  const bool deep_requested =
+      (scrub_level == scrub_level_t::deep) || repair_requested;
+  scrub_level = deep_requested ? scrub_level_t::deep : scrub_level_t::shallow;
   dout(10) << fmt::format(
                  "{}: {}{} scrub requested. "
                  "@entry:{},last-stamp:{:s},Registered?{}",
@@ -675,16 +677,33 @@ scrub_level_t PgScrubber::scrub_requested(
                  m_scrub_job->get_sched_time(), registration_state())
           << dendl;
 
+  // if we were marked as 'not registered' - do not try to push into
+  // the queue.
+  if (!m_scrub_job->is_registered()) {
+    dout(10) << fmt::format(
+                   "{}: pg[{}]: not registered for scrubbing on this OSD",
+                   __func__, m_pg_id)
+            << dendl;
+    return scrub_level_t::shallow;
+  }
+
+  // modifying the planned-scrub flags - to be removed shortly
   req_flags.must_scrub = true;
   req_flags.must_deep_scrub = deep_requested;
-  req_flags.must_repair = (scrub_type == scrub_type_t::do_repair);
+  req_flags.must_repair = repair_requested;
   // User might intervene, so clear this
   req_flags.need_auto = false;
   req_flags.req_scrub = true;
   dout(20) << fmt::format("{}: planned scrub:{}", __func__, req_flags) << dendl;
 
-  update_scrub_job(delay_ready_t::no_delay);
-  return deep_requested ? scrub_level_t::deep : scrub_level_t::shallow;
+  // update the relevant SchedTarget (either shallow or deep). Set its urgency
+  // to either operator_requested or must_repair. Push it into the queue
+  auto& trgt = m_scrub_job->get_target(scrub_level);
+  m_osds->get_scrub_services().dequeue_target(m_pg_id, scrub_level);
+  m_scrub_job->operator_forced(scrub_level, scrub_type);
+  m_osds->get_scrub_services().enqueue_target(trgt);
+
+  return scrub_level;
 }
 
 

diff --git a/src/osd/scrubber/scrub_job.cc b/src/osd/scrubber/scrub_job.cc
index a983f4b70476d009d80636d9f4e8ec045118c4f2..8a51ea0fbc84e8aedb5cb5a33b26e7bb22956aca 100644 (file)
--- a/src/osd/scrubber/scrub_job.cc
+++ b/src/osd/scrubber/scrub_job.cc
@@ -161,6 +161,17 @@ void ScrubJob::adjust_shallow_schedule(
 }
 
 
+void ScrubJob::operator_forced(scrub_level_t s_or_d, scrub_type_t scrub_type)
+{
+  auto& trgt = get_target(s_or_d);
+  trgt.up_urgency_to(
+      (scrub_type == scrub_type_t::do_repair) ? urgency_t::must_repair
+                                             : urgency_t::operator_requested);
+  trgt.sched_info.schedule.scheduled_at = PgScrubber::scrub_must_stamp();
+  trgt.sched_info.schedule.not_before = PgScrubber::scrub_must_stamp();
+}
+
+
 std::optional<std::reference_wrapper<SchedTarget>> ScrubJob::earliest_eligible(
     utime_t scrub_clock_now)
 {

diff --git a/src/osd/scrubber/scrub_job.h b/src/osd/scrubber/scrub_job.h
index cba61ec24c8e7e95edefe8a0a798961743ac9705..014cb0951d93713a8dfc0ad50fae40109dc81516 100644 (file)
--- a/src/osd/scrubber/scrub_job.h
+++ b/src/osd/scrubber/scrub_job.h
@@ -244,6 +244,13 @@ class ScrubJob {
       const Scrub::sched_conf_t& aconf,
       utime_t scrub_clock_now) {}
 
+  /**
+   * the operator requested a scrub (shallow, deep or repair).
+   * Set the selected target to the requested urgency, adjusting scheduling
+   * parameters.
+   */
+  void operator_forced(scrub_level_t s_or_d, scrub_type_t scrub_type);
+
   void dump(ceph::Formatter* f) const;
 
   bool is_registered() const { return registered; }