osd: PG::CephPeeringEvt -> PGPeeringEvent

We need to move this out of the PG class so that we can make an OpQueueItem
specialization for it.

Signed-off-by: Sage Weil <sage@redhat.com>

diff --git a/src/osd/OSD.cc b/src/osd/OSD.cc
index d774581781a581bac02f22dc805d053ab25b3a61..c9df924378850f929c0b2f2982ffbb1ba86bcc3c 100644 (file)
--- a/src/osd/OSD.cc
+++ b/src/osd/OSD.cc
@@ -3745,10 +3745,10 @@ void OSD::add_newly_split_pg(PG *pg, PG::RecoveryCtx *rctx)
   dout(10) << "Adding newly split pg " << *pg << dendl;
   pg->handle_loaded(rctx);
   pg->queue_null(e, e);
-  map<spg_t, list<PG::CephPeeringEvtRef> >::iterator to_wake =
+  map<spg_t, list<PGPeeringEventRef> >::iterator to_wake =
     peering_wait_for_split.find(pg->pg_id);
   if (to_wake != peering_wait_for_split.end()) {
-    for (list<PG::CephPeeringEvtRef>::iterator i =
+    for (list<PGPeeringEventRef>::iterator i =
           to_wake->second.begin();
         i != to_wake->second.end();
         ++i) {
@@ -3974,7 +3974,7 @@ int OSD::handle_pg_peering_evt(
   const pg_history_t& orig_history,
   const PastIntervals& pi,
   epoch_t epoch,
-  PG::CephPeeringEvtRef evt)
+  PGPeeringEventRef evt)
 {
   if (service.splitting(pgid)) {
     peering_wait_for_split[pgid].push_back(evt);
@@ -8238,8 +8238,8 @@ void OSD::handle_pg_create(OpRequestRef op)
           history,
           pi,
           osdmap->get_epoch(),
-          PG::CephPeeringEvtRef(
-           new PG::CephPeeringEvt(
+          PGPeeringEventRef(
+           new PGPeeringEvent(
              osdmap->get_epoch(),
              osdmap->get_epoch(),
              PG::NullEvt()))
@@ -8479,8 +8479,8 @@ void OSD::handle_pg_notify(OpRequestRef op)
       spg_t(it->first.info.pgid.pgid, it->first.to),
       it->first.info.history, it->second,
       it->first.query_epoch,
-      PG::CephPeeringEvtRef(
-       new PG::CephPeeringEvt(
+      PGPeeringEventRef(
+       new PGPeeringEvent(
          it->first.epoch_sent, it->first.query_epoch,
          PG::MNotifyRec(pg_shard_t(from, it->first.from), it->first,
           op->get_req()->get_connection()->get_features())))
@@ -8510,8 +8510,8 @@ void OSD::handle_pg_log(OpRequestRef op)
   handle_pg_peering_evt(
     spg_t(m->get_pgid().pgid, m->to),
     m->info.history, m->past_intervals, m->get_epoch(),
-    PG::CephPeeringEvtRef(
-      new PG::CephPeeringEvt(
+    PGPeeringEventRef(
+      new PGPeeringEvent(
        m->get_epoch(), m->get_query_epoch(),
        PG::MLogRec(pg_shard_t(from, m->from), m)))
     );
@@ -8543,8 +8543,8 @@ void OSD::handle_pg_info(OpRequestRef op)
     handle_pg_peering_evt(
       spg_t(p->first.info.pgid.pgid, p->first.to),
       p->first.info.history, p->second, p->first.epoch_sent,
-      PG::CephPeeringEvtRef(
-       new PG::CephPeeringEvt(
+      PGPeeringEventRef(
+       new PGPeeringEvent(
          p->first.epoch_sent, p->first.query_epoch,
          PG::MInfoRec(
            pg_shard_t(
@@ -8593,16 +8593,16 @@ void OSD::handle_pg_backfill_reserve(OpRequestRef op)
   if (!require_same_or_newer_map(op, m->query_epoch, false))
     return;
 
-  PG::CephPeeringEvtRef evt;
+  PGPeeringEventRef evt;
   if (m->type == MBackfillReserve::REQUEST) {
-    evt = PG::CephPeeringEvtRef(
-      new PG::CephPeeringEvt(
+    evt = PGPeeringEventRef(
+      new PGPeeringEvent(
        m->query_epoch,
        m->query_epoch,
        PG::RequestBackfillPrio(m->priority)));
   } else if (m->type == MBackfillReserve::GRANT) {
-    evt = PG::CephPeeringEvtRef(
-      new PG::CephPeeringEvt(
+    evt = PGPeeringEventRef(
+      new PGPeeringEvent(
        m->query_epoch,
        m->query_epoch,
        PG::RemoteBackfillReserved()));
@@ -8612,26 +8612,26 @@ void OSD::handle_pg_backfill_reserve(OpRequestRef op)
     //                                  (for older peers)
     //      and also replica -> primary "i revoke your reservation"
     //                                  (for older peers)
-    evt = PG::CephPeeringEvtRef(
-      new PG::CephPeeringEvt(
+    evt = PGPeeringEventRef(
+      new PGPeeringEvent(
        m->query_epoch,
        m->query_epoch,
        PG::RemoteReservationRejected()));
   } else if (m->type == MBackfillReserve::RELEASE) {
-    evt = PG::CephPeeringEvtRef(
-      new PG::CephPeeringEvt(
+    evt = PGPeeringEventRef(
+      new PGPeeringEvent(
        m->query_epoch,
        m->query_epoch,
        PG::RemoteReservationCanceled()));
   } else if (m->type == MBackfillReserve::TOOFULL) {
-    evt = PG::CephPeeringEvtRef(
-      new PG::CephPeeringEvt(
+    evt = PGPeeringEventRef(
+      new PGPeeringEvent(
        m->query_epoch,
        m->query_epoch,
        PG::RemoteReservationRevokedTooFull()));
   } else if (m->type == MBackfillReserve::REVOKE) {
-    evt = PG::CephPeeringEvtRef(
-      new PG::CephPeeringEvt(
+    evt = PGPeeringEventRef(
+      new PGPeeringEvent(
        m->query_epoch,
        m->query_epoch,
        PG::RemoteReservationRevoked()));
@@ -8664,28 +8664,28 @@ void OSD::handle_pg_recovery_reserve(OpRequestRef op)
   if (!require_same_or_newer_map(op, m->query_epoch, false))
     return;
 
-  PG::CephPeeringEvtRef evt;
+  PGPeeringEventRef evt;
   if (m->type == MRecoveryReserve::REQUEST) {
-    evt = PG::CephPeeringEvtRef(
-      new PG::CephPeeringEvt(
+    evt = PGPeeringEventRef(
+      new PGPeeringEvent(
        m->query_epoch,
        m->query_epoch,
        PG::RequestRecoveryPrio(m->priority)));
   } else if (m->type == MRecoveryReserve::GRANT) {
-    evt = PG::CephPeeringEvtRef(
-      new PG::CephPeeringEvt(
+    evt = PGPeeringEventRef(
+      new PGPeeringEvent(
        m->query_epoch,
        m->query_epoch,
        PG::RemoteRecoveryReserved()));
   } else if (m->type == MRecoveryReserve::RELEASE) {
-    evt = PG::CephPeeringEvtRef(
-      new PG::CephPeeringEvt(
+    evt = PGPeeringEventRef(
+      new PGPeeringEvent(
        m->query_epoch,
        m->query_epoch,
        PG::RecoveryDone()));
   } else if (m->type == MRecoveryReserve::REVOKE) {
-    evt = PG::CephPeeringEvtRef(
-      new PG::CephPeeringEvt(
+    evt = PGPeeringEventRef(
+      new PGPeeringEvent(
        m->query_epoch,
        m->query_epoch,
        PG::DeferRecovery(0.0)));
@@ -8772,8 +8772,8 @@ void OSD::handle_pg_query(OpRequestRef op)
 
     if (service.splitting(pgid)) {
       peering_wait_for_split[pgid].push_back(
-       PG::CephPeeringEvtRef(
-         new PG::CephPeeringEvt(
+       PGPeeringEventRef(
+         new PGPeeringEvent(
            it->second.epoch_sent, it->second.epoch_sent,
            PG::MQuery(pg_shard_t(from, it->second.from),
                       it->second, it->second.epoch_sent))));

diff --git a/src/osd/OSD.h b/src/osd/OSD.h
index bc20926a590d1ca831c7b19fe98630fdaec9ee8c..2baa821d56e39592b31905e46765437aad57ea3c 100644 (file)
--- a/src/osd/OSD.h
+++ b/src/osd/OSD.h
@@ -1928,7 +1928,7 @@ protected:
   std::set<create_from_osd_t> pending_creates_from_osd;
   unsigned pending_creates_from_mon = 0;
 
-  map<spg_t, list<PG::CephPeeringEvtRef> > peering_wait_for_split;
+  map<spg_t, list<PGPeeringEventRef> > peering_wait_for_split;
   PGRecoveryStats pg_recovery_stats;
 
   PGPool _get_pool(int id, OSDMapRef createmap);
@@ -1976,7 +1976,7 @@ protected:
     const pg_history_t& orig_history,
     const PastIntervals& pi,
     epoch_t epoch,
-    PG::CephPeeringEvtRef evt);
+    PGPeeringEventRef evt);
   bool maybe_wait_for_max_pg(spg_t pgid, bool is_mon_create);
   void resume_creating_pg();
 

diff --git a/src/osd/PG.cc b/src/osd/PG.cc
index 792165ba3ac6c89734df06a41b85809e78aef2ff..8d8e3caaed381b4f085b31c47149a49e4cb4daf8 100644 (file)
--- a/src/osd/PG.cc
+++ b/src/osd/PG.cc
@@ -90,7 +90,7 @@ static ostream& _prefix(std::ostream *_dout, T *t)
   return *_dout << t->gen_prefix();
 }
 
-MEMPOOL_DEFINE_OBJECT_FACTORY(PG::CephPeeringEvt, pg_peering_evt, osd);
+MEMPOOL_DEFINE_OBJECT_FACTORY(PGPeeringEvent, pg_peering_evt, osd);
 
 void PGStateHistory::enter(PG* pg, const utime_t entime, const char* state)
 {
@@ -1968,8 +1968,8 @@ void PG::all_activated_and_committed()
   assert(blocked_by.empty());
 
   queue_peering_event(
-    CephPeeringEvtRef(
-      std::make_shared<CephPeeringEvt>(
+    PGPeeringEventRef(
+      std::make_shared<PGPeeringEvent>(
         get_osdmap()->get_epoch(),
         get_osdmap()->get_epoch(),
         AllReplicasActivated())));
@@ -4990,8 +4990,8 @@ void PG::scrub_finish()
 
   if (has_error) {
     queue_peering_event(
-      CephPeeringEvtRef(
-       std::make_shared<CephPeeringEvt>(
+      PGPeeringEventRef(
+       std::make_shared<PGPeeringEvent>(
          get_osdmap()->get_epoch(),
          get_osdmap()->get_epoch(),
          DoRecovery())));
@@ -5787,7 +5787,7 @@ void PG::take_waiters()
 {
   dout(10) << "take_waiters" << dendl;
   requeue_map_waiters();
-  for (list<CephPeeringEvtRef>::iterator i = peering_waiters.begin();
+  for (list<PGPeeringEventRef>::iterator i = peering_waiters.begin();
        i != peering_waiters.end();
        ++i) osd->queue_for_peering(this);
   peering_queue.splice(peering_queue.begin(), peering_waiters,
@@ -5797,7 +5797,7 @@ void PG::take_waiters()
 void PG::process_peering_event(RecoveryCtx *rctx)
 {
   assert(!peering_queue.empty());
-  CephPeeringEvtRef evt = peering_queue.front();
+  PGPeeringEventRef evt = peering_queue.front();
   peering_queue.pop_front();
 
   dout(10) << __func__ << ": " << evt->get_desc() << dendl;
@@ -5812,7 +5812,7 @@ void PG::process_peering_event(RecoveryCtx *rctx)
   write_if_dirty(*rctx->transaction);
 }
 
-void PG::queue_peering_event(CephPeeringEvtRef evt)
+void PG::queue_peering_event(PGPeeringEventRef evt)
 {
   if (old_peering_evt(evt))
     return;
@@ -5825,7 +5825,7 @@ void PG::queue_null(epoch_t msg_epoch,
 {
   dout(10) << "null" << dendl;
   queue_peering_event(
-    CephPeeringEvtRef(std::make_shared<CephPeeringEvt>(msg_epoch, query_epoch,
+    PGPeeringEventRef(std::make_shared<PGPeeringEvent>(msg_epoch, query_epoch,
                                         NullEvt())));
 }
 
@@ -5833,7 +5833,7 @@ void PG::queue_flushed(epoch_t e)
 {
   dout(10) << "flushed" << dendl;
   queue_peering_event(
-    CephPeeringEvtRef(std::make_shared<CephPeeringEvt>(e, e,
+    PGPeeringEventRef(std::make_shared<PGPeeringEvent>(e, e,
                                         FlushedEvt())));
 }
 
@@ -5843,7 +5843,7 @@ void PG::queue_query(epoch_t msg_epoch,
 {
   dout(10) << "handle_query " << q << " from replica " << from << dendl;
   queue_peering_event(
-    CephPeeringEvtRef(std::make_shared<CephPeeringEvt>(msg_epoch, query_epoch,
+    PGPeeringEventRef(std::make_shared<PGPeeringEvent>(msg_epoch, query_epoch,
                                         MQuery(from, q, query_epoch))));
 }
 
@@ -5859,16 +5859,16 @@ void PG::find_unfound(epoch_t queued, RecoveryCtx *rctx)
   if (rctx->query_map->empty()) {
     string action;
     if (state_test(PG_STATE_BACKFILLING)) {
-      auto evt = PG::CephPeeringEvtRef(
-       new PG::CephPeeringEvt(
+      auto evt = PGPeeringEventRef(
+       new PGPeeringEvent(
          queued,
          queued,
          PG::UnfoundBackfill()));
       queue_peering_event(evt);
       action = "in backfill";
     } else if (state_test(PG_STATE_RECOVERING)) {
-      auto evt = PG::CephPeeringEvtRef(
-       new PG::CephPeeringEvt(
+      auto evt = PGPeeringEventRef(
+       new PGPeeringEvent(
          queued,
          queued,
          PG::UnfoundRecovery()));

diff --git a/src/osd/PG.h b/src/osd/PG.h
index 37cc3e9b9838698b13245bdefc5d616c5f8e95b5..edbdb15d1aad6d32887acc24bf8b2c23b0b82b55 100644 (file)
--- a/src/osd/PG.h
+++ b/src/osd/PG.h
@@ -43,6 +43,7 @@
 #include "messages/MOSDPGLog.h"
 #include "include/str_list.h"
 #include "PGBackend.h"
+#include "PGPeeringEvent.h"
 
 #include <atomic>
 #include <list>
@@ -256,33 +257,6 @@ public:
 
   ObjectStore::CollectionHandle ch;
 
-  // -- classes --
-  class CephPeeringEvt {
-    epoch_t epoch_sent;
-    epoch_t epoch_requested;
-    boost::intrusive_ptr< const boost::statechart::event_base > evt;
-    string desc;
-  public:
-    MEMPOOL_CLASS_HELPERS();
-    template <class T>
-    CephPeeringEvt(epoch_t epoch_sent,
-                  epoch_t epoch_requested,
-                  const T &evt_) :
-      epoch_sent(epoch_sent), epoch_requested(epoch_requested),
-      evt(evt_.intrusive_from_this()) {
-      stringstream out;
-      out << "epoch_sent: " << epoch_sent
-         << " epoch_requested: " << epoch_requested << " ";
-      evt_.print(&out);
-      desc = out.str();
-    }
-    epoch_t get_epoch_sent() { return epoch_sent; }
-    epoch_t get_epoch_requested() { return epoch_requested; }
-    const boost::statechart::event_base &get_event() { return *evt; }
-    string get_desc() { return desc; }
-  };
-  typedef ceph::shared_ptr<CephPeeringEvt> CephPeeringEvtRef;
-
   class RecoveryCtx;
 
   // -- methods --
@@ -432,7 +406,7 @@ public:
   bool set_force_recovery(bool b);
   bool set_force_backfill(bool b);
 
-  void queue_peering_event(CephPeeringEvtRef evt);
+  void queue_peering_event(PGPeeringEventRef evt);
   void process_peering_event(RecoveryCtx *rctx);
   void queue_query(epoch_t msg_epoch, epoch_t query_epoch,
                   pg_shard_t from, const pg_query_t& q);
@@ -1686,8 +1660,8 @@ protected:
       pg(pg), epoch(epoch), evt(evt) {}
     void finish(int r) override {
       pg->lock();
-      pg->queue_peering_event(PG::CephPeeringEvtRef(
-                               new PG::CephPeeringEvt(
+      pg->queue_peering_event(PGPeeringEventRef(
+                               new PGPeeringEvent(
                                  epoch,
                                  epoch,
                                  evt)));
@@ -1696,8 +1670,8 @@ protected:
   };
 
 
-  list<CephPeeringEvtRef> peering_queue;  // op queue
-  list<CephPeeringEvtRef> peering_waiters;
+  list<PGPeeringEventRef> peering_queue;  // op queue
+  list<PGPeeringEventRef> peering_waiters;
 
   struct QueryState : boost::statechart::event< QueryState > {
     Formatter *f;
@@ -2577,7 +2551,7 @@ protected:
       end_handle();
     }
 
-    void handle_event(CephPeeringEvtRef evt,
+    void handle_event(PGPeeringEventRef evt,
                      RecoveryCtx *rctx) {
       start_handle(rctx);
       machine.process_event(evt->get_event());
@@ -2809,7 +2783,7 @@ protected:
   bool can_discard_replica_op(OpRequestRef& op);
 
   bool old_peering_msg(epoch_t reply_epoch, epoch_t query_epoch);
-  bool old_peering_evt(CephPeeringEvtRef evt) {
+  bool old_peering_evt(PGPeeringEventRef evt) {
     return old_peering_msg(evt->get_epoch_sent(), evt->get_epoch_requested());
   }
   static bool have_same_or_newer_map(epoch_t cur_epoch, epoch_t e) {

diff --git a/src/osd/PGPeeringEvent.h b/src/osd/PGPeeringEvent.h
new file mode 100644 (file)
index 0000000..f328a7d
--- /dev/null
+++ b/src/osd/PGPeeringEvent.h
@@ -0,0 +1,42 @@
+// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
+// vim: ts=8 sw=2 smarttab
+
+#pragma once
+
+#include <boost/statechart/event.hpp>
+
+class PGPeeringEvent {
+  epoch_t epoch_sent;
+  epoch_t epoch_requested;
+  boost::intrusive_ptr< const boost::statechart::event_base > evt;
+  string desc;
+public:
+  MEMPOOL_CLASS_HELPERS();
+  template <class T>
+  PGPeeringEvent(
+    epoch_t epoch_sent,
+    epoch_t epoch_requested,
+    const T &evt_)
+    : epoch_sent(epoch_sent),
+      epoch_requested(epoch_requested),
+      evt(evt_.intrusive_from_this()) {
+    stringstream out;
+    out << "epoch_sent: " << epoch_sent
+       << " epoch_requested: " << epoch_requested << " ";
+    evt_.print(&out);
+    desc = out.str();
+  }
+  epoch_t get_epoch_sent() {
+    return epoch_sent;
+  }
+  epoch_t get_epoch_requested() {
+    return epoch_requested;
+  }
+  const boost::statechart::event_base &get_event() {
+    return *evt;
+  }
+  const string& get_desc() {
+    return desc;
+  }
+};
+typedef ceph::shared_ptr<PGPeeringEvent> PGPeeringEventRef;

diff --git a/src/osd/PrimaryLogPG.cc b/src/osd/PrimaryLogPG.cc
index 48c678ce735c408f8e90f13ba05fc4c0ab7c9b36..60247fdc0b7202f659d93fbd68c87ce304bb9de8 100644 (file)
--- a/src/osd/PrimaryLogPG.cc
+++ b/src/osd/PrimaryLogPG.cc
@@ -3445,8 +3445,8 @@ void PrimaryLogPG::do_scan(
       if (osd->check_backfill_full(ss)) {
        dout(1) << __func__ << ": Canceling backfill, " << ss.str() << dendl;
        queue_peering_event(
-         CephPeeringEvtRef(
-           std::make_shared<CephPeeringEvt>(
+         PGPeeringEventRef(
+           std::make_shared<PGPeeringEvent>(
              get_osdmap()->get_epoch(),
              get_osdmap()->get_epoch(),
              BackfillTooFull())));
@@ -3523,8 +3523,8 @@ void PrimaryLogPG::do_backfill(OpRequestRef op)
       reply->set_priority(get_recovery_op_priority());
       osd->send_message_osd_cluster(reply, m->get_connection());
       queue_peering_event(
-       CephPeeringEvtRef(
-         std::make_shared<CephPeeringEvt>(
+       PGPeeringEventRef(
+         std::make_shared<PGPeeringEvent>(
            get_osdmap()->get_epoch(),
            get_osdmap()->get_epoch(),
            RecoveryDone())));
@@ -10587,15 +10587,15 @@ void PrimaryLogPG::mark_all_unfound_lost(
 
        if (is_recovery_unfound()) {
          queue_peering_event(
-           CephPeeringEvtRef(
-             std::make_shared<CephPeeringEvt>(
+           PGPeeringEventRef(
+             std::make_shared<PGPeeringEvent>(
              get_osdmap()->get_epoch(),
              get_osdmap()->get_epoch(),
              DoRecovery())));
        } else if (is_backfill_unfound()) {
          queue_peering_event(
-           CephPeeringEvtRef(
-             std::make_shared<CephPeeringEvt>(
+           PGPeeringEventRef(
+             std::make_shared<PGPeeringEvent>(
              get_osdmap()->get_epoch(),
              get_osdmap()->get_epoch(),
              RequestBackfill())));
@@ -10796,16 +10796,16 @@ void PrimaryLogPG::on_activate()
   if (needs_recovery()) {
     dout(10) << "activate not all replicas are up-to-date, queueing recovery" << dendl;
     queue_peering_event(
-      CephPeeringEvtRef(
-       std::make_shared<CephPeeringEvt>(
+      PGPeeringEventRef(
+       std::make_shared<PGPeeringEvent>(
          get_osdmap()->get_epoch(),
          get_osdmap()->get_epoch(),
          DoRecovery())));
   } else if (needs_backfill()) {
     dout(10) << "activate queueing backfill" << dendl;
     queue_peering_event(
-      CephPeeringEvtRef(
-       std::make_shared<CephPeeringEvt>(
+      PGPeeringEventRef(
+       std::make_shared<PGPeeringEvent>(
          get_osdmap()->get_epoch(),
          get_osdmap()->get_epoch(),
          RequestBackfill())));
@@ -10813,8 +10813,8 @@ void PrimaryLogPG::on_activate()
     dout(10) << "activate all replicas clean, no recovery" << dendl;
     eio_errors_to_process = false;
     queue_peering_event(
-      CephPeeringEvtRef(
-       std::make_shared<CephPeeringEvt>(
+      PGPeeringEventRef(
+       std::make_shared<PGPeeringEvent>(
          get_osdmap()->get_epoch(),
          get_osdmap()->get_epoch(),
          AllReplicasRecovered())));
@@ -11184,8 +11184,8 @@ bool PrimaryLogPG::start_recovery_ops(
        dout(10) << "queueing RequestBackfill" << dendl;
        backfill_reserving = true;
        queue_peering_event(
-         CephPeeringEvtRef(
-           std::make_shared<CephPeeringEvt>(
+         PGPeeringEventRef(
+           std::make_shared<PGPeeringEvent>(
              get_osdmap()->get_epoch(),
              get_osdmap()->get_epoch(),
              RequestBackfill())));
@@ -11242,8 +11242,8 @@ bool PrimaryLogPG::start_recovery_ops(
     if (needs_backfill()) {
       dout(10) << "recovery done, queuing backfill" << dendl;
       queue_peering_event(
-        CephPeeringEvtRef(
-          std::make_shared<CephPeeringEvt>(
+        PGPeeringEventRef(
+          std::make_shared<PGPeeringEvent>(
             get_osdmap()->get_epoch(),
             get_osdmap()->get_epoch(),
             RequestBackfill())));
@@ -11252,8 +11252,8 @@ bool PrimaryLogPG::start_recovery_ops(
       eio_errors_to_process = false;
       state_clear(PG_STATE_FORCED_BACKFILL);
       queue_peering_event(
-        CephPeeringEvtRef(
-          std::make_shared<CephPeeringEvt>(
+        PGPeeringEventRef(
+          std::make_shared<PGPeeringEvent>(
             get_osdmap()->get_epoch(),
             get_osdmap()->get_epoch(),
             AllReplicasRecovered())));
@@ -11265,8 +11265,8 @@ bool PrimaryLogPG::start_recovery_ops(
     dout(10) << "recovery done, backfill done" << dendl;
     eio_errors_to_process = false;
     queue_peering_event(
-      CephPeeringEvtRef(
-        std::make_shared<CephPeeringEvt>(
+      PGPeeringEventRef(
+        std::make_shared<PGPeeringEvent>(
           get_osdmap()->get_epoch(),
           get_osdmap()->get_epoch(),
           Backfilled())));
@@ -13921,8 +13921,8 @@ int PrimaryLogPG::rep_repair_primary_object(const hobject_t& soid, OpRequestRef
     eio_errors_to_process = true;
     assert(is_clean());
     queue_peering_event(
-        CephPeeringEvtRef(
-         std::make_shared<CephPeeringEvt>(
+        PGPeeringEventRef(
+         std::make_shared<PGPeeringEvent>(
          get_osdmap()->get_epoch(),
          get_osdmap()->get_epoch(),
          DoRecovery())));