crimson: remove CommonClientRequest, move do_recover_missing to PG

do_recover_missing was the only thing left, and inheriting from a class
to get a static method is somewhat confusing.  Simply move
do_recover_missing to PG.

Signed-off-by: Samuel Just <[email protected]>
(cherry picked from commit ee11626)

Author: athanatos

src/crimson/osd/CMakeLists.txt

@@ -19,7 +19,6 @@ add_executable(crimson-osd
   ops_executer.cc
   osd_operation.cc
   osd_operations/client_request.cc
-  osd_operations/client_request_common.cc
   osd_operations/internal_client_request.cc
   osd_operations/peering_event.cc
   osd_operations/pg_advance_map.cc

src/crimson/osd/osd_operations/client_request.cc

@@ -321,7 +321,7 @@ ClientRequest::recover_missing_snaps(
   co_await std::move(resolve_oids);
 
   for (auto &oid : ret) {
-    auto unfound = co_await do_recover_missing(pg, oid, m->get_reqid());
+    auto unfound = co_await pg->do_recover_missing(oid, m->get_reqid());
     if (unfound) {
       DEBUGDPP("{} unfound, hang it for now", *pg, oid);
       co_await interruptor::make_interruptible(
@@ -347,8 +347,8 @@ ClientRequest::process_op(
       "Skipping recover_missings on non primary pg for soid {}",
       *pg, m->get_hobj());
   } else {
-    auto unfound = co_await do_recover_missing(
-      pg, m->get_hobj().get_head(), m->get_reqid());
+    auto unfound = co_await pg->do_recover_missing(
+      m->get_hobj().get_head(), m->get_reqid());
     if (unfound) {
       DEBUGDPP("{} unfound, hang it for now", *pg, m->get_hobj().get_head());
       co_await interruptor::make_interruptible(

src/crimson/osd/osd_operations/client_request.h

@@ -15,7 +15,6 @@
 #include "crimson/osd/object_context_loader.h"
 #include "crimson/osd/osdmap_gate.h"
 #include "crimson/osd/osd_operation.h"
-#include "crimson/osd/osd_operations/client_request_common.h"
 #include "crimson/osd/pg_activation_blocker.h"
 #include "crimson/osd/pg_map.h"
 #include "crimson/osd/scrub/pg_scrubber.h"
@@ -28,8 +27,7 @@ class PG;
 class OSD;
 class ShardServices;
 
-class ClientRequest final : public PhasedOperationT<ClientRequest>,
-                            private CommonClientRequest {
+class ClientRequest final : public PhasedOperationT<ClientRequest> {
   // Initially set to primary core, updated to pg core after with_pg()
   ShardServices *shard_services = nullptr;
 

src/crimson/osd/osd_operations/client_request_common.cc

@@ -64,8 +64,8 @@ InternalClientRequest::with_interruption()
 
   co_await enter_stage<interruptor>(obc_orderer->obc_pp().process);
 
-  bool unfound = co_await do_recover_missing(
-    pg, get_target_oid(), osd_reqid_t());
+  bool unfound = co_await pg->do_recover_missing(
+    get_target_oid(), osd_reqid_t());
 
   if (unfound) {
     throw std::system_error(

src/crimson/osd/osd_operations/client_request_common.h

@@ -6,14 +6,12 @@
 #include "crimson/common/type_helpers.h"
 #include "crimson/osd/object_context_loader.h"
 #include "crimson/osd/osd_operation.h"
-#include "crimson/osd/osd_operations/client_request_common.h"
 #include "crimson/osd/pg.h"
 #include "crimson/osd/pg_activation_blocker.h"
 
 namespace crimson::osd {
 
-class InternalClientRequest : public PhasedOperationT<InternalClientRequest>,
-                              private CommonClientRequest {
+class InternalClientRequest : public PhasedOperationT<InternalClientRequest> {
 public:
   explicit InternalClientRequest(Ref<PG> pg);
   ~InternalClientRequest();

src/crimson/osd/osd_operations/internal_client_request.cc

@@ -660,6 +660,69 @@ void PG::on_active_advmap(const OSDMapRef &osdmap)
   }
 }
 
+PG::interruptible_future<bool> PG::do_recover_missing(
+  const hobject_t& soid,
+  const osd_reqid_t& reqid)
+{
+  LOG_PREFIX(PG::do_recover_missing);
+  DEBUGDPP(
+    "reqid {} check for recovery, {}",
+    *this, reqid, soid);
+  assert(is_primary());
+  eversion_t ver;
+  auto &missing_loc = peering_state.get_missing_loc();
+  bool needs_recovery_or_backfill = false;
+
+  if (is_unreadable_object(soid)) {
+    DEBUGDPP(
+      "reqid {}, {} is unreadable",
+      *this, reqid, soid);
+    ceph_assert(missing_loc.needs_recovery(soid, &ver));
+    needs_recovery_or_backfill = true;
+  }
+
+  if (is_degraded_or_backfilling_object(soid)) {
+    DEBUGDPP(
+      "reqid {}, {} is degraded or backfilling",
+      *this, reqid, soid);
+    if (missing_loc.needs_recovery(soid, &ver)) {
+      needs_recovery_or_backfill = true;
+    }
+  }
+
+  if (!needs_recovery_or_backfill) {
+    DEBUGDPP(
+      "reqid {} nothing to recover {}",
+      *this, reqid, soid);
+    co_return false;
+  }
+
+  if (peering_state.get_missing_loc().is_unfound(soid)) {
+    co_return true;
+  }
+  DEBUGDPP(
+    "reqid {} need to wait for recovery, {} version {}",
+    *this, reqid, soid);
+  if (recovery_backend->is_recovering(soid)) {
+    DEBUGDPP(
+      "reqid {} object {} version {}, already recovering",
+      *this, reqid, soid, ver);
+    co_await PG::interruptor::make_interruptible(
+      recovery_backend->get_recovering(
+	soid).wait_for_recovered());
+    co_return false;
+  } else {
+    DEBUGDPP(
+      "reqid {} object {} version {}, starting recovery",
+      *this, reqid, soid, ver);
+    auto [op, fut] =
+      shard_services.start_operation<UrgentRecovery>(
+        soid, ver, this, shard_services, get_osdmap_epoch());
+    co_await PG::interruptor::make_interruptible(std::move(fut));
+    co_return false;
+  }
+}
+
 void PG::scrub_requested(scrub_level_t scrub_level, scrub_type_t scrub_type)
 {
   /* We don't actually route the scrub request message into the state machine.

src/crimson/osd/osd_operations/internal_client_request.h

@@ -760,6 +760,10 @@ class PG : public boost::intrusive_ref_counter<
 public:
   PeeringState peering_state;
 
+  interruptible_future<bool> do_recover_missing(
+    const hobject_t& soid,
+    const osd_reqid_t& reqid);
+
   // scrub state
 
   friend class ScrubScan;