osd: squeeze RecoveryHandle out of ECCommon::RecoveryBackend

Signed-off-by: Radoslaw Zarzynski <rzarzyns@redhat.com>
(cherry picked from commit 1e0feb73a4b91bd8b7b3ecc164d28fe005b97ed1)

diff --git a/src/osd/ECBackend.cc b/src/osd/ECBackend.cc
index 7bc6b28649a8777287d815e941facaf80744be41..c5d5514d61bdb4647e85db4cd242d5445eaaa61e 100644 (file)
--- a/src/osd/ECBackend.cc
+++ b/src/osd/ECBackend.cc
@@ -63,8 +63,8 @@ static ostream &_prefix(std::ostream *_dout, ECBackend::RecoveryBackend *pgb) {
   return pgb->get_parent()->gen_dbg_prefix(*_dout);
 }
 
-struct ECCommon::RecoveryBackend::ECRecoveryHandle : public PGBackend::RecoveryHandle {
-  list<ECBackend::RecoveryBackend::RecoveryOp> ops;
+struct ECBackend::ECRecoveryBackend::ECRecoveryHandle : public PGBackend::RecoveryHandle {
+  list<ECCommon::RecoveryBackend::RecoveryOp> ops;
 };
 
 void ECBackend::RecoveryBackend::RecoveryOp::dump(Formatter *f) const {
@@ -121,7 +121,7 @@ ECBackend::RecoveryBackend::RecoveryBackend(
     read_pipeline(read_pipeline),
     parent(parent) {}
 
-ECCommon::RecoveryBackend::ECRecoveryHandle *ECBackend::RecoveryBackend::open_recovery_op() {
+ECBackend::ECRecoveryBackend::ECRecoveryHandle *ECBackend::ECRecoveryBackend::open_recovery_op() {
   return new ECRecoveryHandle;
 }
 
@@ -740,14 +740,14 @@ void ECBackend::run_recovery_op(
   PGBackend::RecoveryHandle *_h,
   int priority) {
   ceph_assert(_h);
-  auto &h = static_cast<ECCommon::RecoveryBackend::ECRecoveryHandle&>(*_h);
+  auto &h = static_cast<ECBackend::ECRecoveryBackend::ECRecoveryHandle&>(*_h);
   recovery_backend.run_recovery_op(h, priority);
   switcher->send_recovery_deletes(priority, h.deletes);
   delete _h;
 }
 
-void ECBackend::RecoveryBackend::run_recovery_op(
-  ECCommon::RecoveryBackend::ECRecoveryHandle &h,
+void ECBackend::ECRecoveryBackend::run_recovery_op(
+  ECBackend::ECRecoveryBackend::ECRecoveryHandle &h,
   int priority) {
   RecoveryMessages m;
   for (list<RecoveryOp>::iterator i = h.ops.begin();
@@ -767,50 +767,51 @@ int ECBackend::recover_object(
   ObjectContextRef head,
   ObjectContextRef obc,
   PGBackend::RecoveryHandle *_h) {
-  auto *h = static_cast<ECCommon::RecoveryBackend::ECRecoveryHandle*>(_h);
-  return recovery_backend.recover_object(hoid, v, head, obc, h);
+  auto *h = static_cast<ECBackend::ECRecoveryBackend::ECRecoveryHandle*>(_h);
+  h->ops.push_back(recovery_backend.recover_object(hoid, v, head, obc));
+  return 0;
 }
 
-int ECBackend::RecoveryBackend::recover_object(
+ECCommon::RecoveryBackend::RecoveryOp
+ECCommon::RecoveryBackend::recover_object(
   const hobject_t &hoid,
   eversion_t v,
   ObjectContextRef head,
-  ObjectContextRef obc,
-  ECCommon::RecoveryBackend::ECRecoveryHandle *h) {
-  h->ops.push_back(RecoveryOp());
-  h->ops.back().v = v;
-  h->ops.back().hoid = hoid;
-  h->ops.back().obc = obc;
-  h->ops.back().recovery_info.soid = hoid;
-  h->ops.back().recovery_info.version = v;
+  ObjectContextRef obc) {
+  RecoveryOp op;
+  op.v = v;
+  op.hoid = hoid;
+  op.obc = obc;
+  op.recovery_info.soid = hoid;
+  op.recovery_info.version = v;
   if (obc) {
-    h->ops.back().recovery_info.size = obc->obs.oi.size;
-    h->ops.back().recovery_info.oi = obc->obs.oi;
+    op.recovery_info.size = obc->obs.oi.size;
+    op.recovery_info.oi = obc->obs.oi;
   }
   if (hoid.is_snap()) {
     if (obc) {
       ceph_assert(obc->ssc);
-      h->ops.back().recovery_info.ss = obc->ssc->snapset;
+      op.recovery_info.ss = obc->ssc->snapset;
     } else if (head) {
       ceph_assert(head->ssc);
-      h->ops.back().recovery_info.ss = head->ssc->snapset;
+      op.recovery_info.ss = head->ssc->snapset;
     } else {
       ceph_abort_msg("neither obc nor head set for a snap object");
     }
   }
-  h->ops.back().recovery_progress.omap_complete = true;
+  op.recovery_progress.omap_complete = true;
   for (set<pg_shard_t>::const_iterator i =
          get_parent()->get_acting_recovery_backfill_shards().begin();
        i != get_parent()->get_acting_recovery_backfill_shards().end();
        ++i) {
     dout(10) << "checking " << *i << dendl;
     if (get_parent()->get_shard_missing(*i).is_missing(hoid)) {
-      h->ops.back().missing_on.insert(*i);
-      h->ops.back().missing_on_shards.insert(i->shard);
+      op.missing_on.insert(*i);
+      op.missing_on_shards.insert(i->shard);
     }
   }
-  dout(10) << __func__ << ": built op " << h->ops.back() << dendl;
-  return 0;
+  dout(10) << __func__ << ": built op " << op << dendl;
+  return op;
 }
 
 bool ECBackend::can_handle_while_inactive(

diff --git a/src/osd/ECBackend.h b/src/osd/ECBackend.h
index a094477a959d20ad7d182683bbe2b962d88c5d44..4881043dcb22a7c7f0aabd0a555af4b295e2342b 100644 (file)
--- a/src/osd/ECBackend.h
+++ b/src/osd/ECBackend.h
@@ -192,6 +192,14 @@ class ECBackend : public ECCommon {
                         parent->get_eclistener()),
         parent(parent) {}
 
+    struct ECRecoveryHandle;
+
+    ECRecoveryHandle *open_recovery_op();
+
+    void run_recovery_op(
+      ECRecoveryHandle &h,
+      int priority);
+
     void commit_txn_send_replies(
         ceph::os::Transaction &&txn,
         std::map<int, MOSDPGPushReply*> replies) override;

diff --git a/src/osd/ECCommon.h b/src/osd/ECCommon.h
index dc1496b25572300d84bf1e1edddae953cab49f03..a22ef5d0115d015a5cf7e2afa2690540c181ff61 100644 (file)
--- a/src/osd/ECCommon.h
+++ b/src/osd/ECCommon.h
@@ -761,17 +761,11 @@ struct ECCommon {
         std::map<int, MOSDPGPushReply*> replies) = 0;
     void dispatch_recovery_messages(RecoveryMessages &m, int priority);
 
-    struct ECRecoveryHandle;
-    ECRecoveryHandle *open_recovery_op();
-    void run_recovery_op(
-        ECRecoveryHandle &h,
-        int priority);
-    int recover_object(
+    RecoveryBackend::RecoveryOp recover_object(
         const hobject_t &hoid,
         eversion_t v,
         ObjectContextRef head,
-        ObjectContextRef obc,
-        ECRecoveryHandle *h);
+        ObjectContextRef obc);
     void continue_recovery_op(
         RecoveryBackend::RecoveryOp &op,
         RecoveryMessages *m);