PeeringState: introduce a macro for the ps, pl, and pg declarations

This way I can mechanically rename all of the PeeringState member
variable references.

Signed-off-by: Samuel Just <sjust@redhat.com>

diff --git a/src/osd/PeeringState.cc b/src/osd/PeeringState.cc
index bc0b59135b7b031f3b569df97f3971c00813aed0..d4fac11968a868266b840e1f83490f5bfd4ccf88 100644 (file)
--- a/src/osd/PeeringState.cc
+++ b/src/osd/PeeringState.cc
@@ -1033,6 +1033,15 @@ PastIntervals::PriorSet PeeringState::build_prior()
 #undef psdout
 #define psdout(x) ldout(context< PeeringMachine >().cct, x)
 
+#define DECLARE_LOCALS                                  \
+  PG *pg = context< PeeringMachine >().pg;              \
+  std::ignore = pg;                                     \
+  PeeringState *ps = context< PeeringMachine >().state; \
+  std::ignore = ps;                                     \
+  PeeringListener *pl = context< PeeringMachine >().pl; \
+  std::ignore = pl;
+
+
 /*------Crashed-------*/
 PeeringState::Crashed::Crashed(my_context ctx)
   : my_base(ctx),
@@ -1053,7 +1062,7 @@ PeeringState::Initial::Initial(my_context ctx)
 
 boost::statechart::result PeeringState::Initial::react(const MNotifyRec& notify)
 {
-  PeeringState *ps = context< PeeringMachine >().state;
+  DECLARE_LOCALS
   ps->proc_replica_info(
     notify.from, notify.notify.info, notify.notify.epoch_sent);
   ps->set_last_peering_reset();
@@ -1062,7 +1071,7 @@ boost::statechart::result PeeringState::Initial::react(const MNotifyRec& notify)
 
 boost::statechart::result PeeringState::Initial::react(const MInfoRec& i)
 {
-  PeeringState *ps = context< PeeringMachine >().state;
+  DECLARE_LOCALS
   ceph_assert(!ps->is_primary());
   post_event(i);
   return transit< Stray >();
@@ -1070,7 +1079,7 @@ boost::statechart::result PeeringState::Initial::react(const MInfoRec& i)
 
 boost::statechart::result PeeringState::Initial::react(const MLogRec& i)
 {
-  PeeringState *ps = context< PeeringMachine >().state;
+  DECLARE_LOCALS
   ceph_assert(!ps->is_primary());
   post_event(i);
   return transit< Stray >();
@@ -1079,7 +1088,7 @@ boost::statechart::result PeeringState::Initial::react(const MLogRec& i)
 void PeeringState::Initial::exit()
 {
   context< PeeringMachine >().log_exit(state_name, enter_time);
-  PeeringListener *pl = context< PeeringMachine >().pl;
+  DECLARE_LOCALS
   utime_t dur = ceph_clock_now() - enter_time;
   pl->get_peering_perf().tinc(rs_initial_latency, dur);
 }
@@ -1102,7 +1111,7 @@ PeeringState::Started::react(const IntervalFlush&)
 
 boost::statechart::result PeeringState::Started::react(const AdvMap& advmap)
 {
-  PeeringState *ps = context< PeeringMachine >().state;
+  DECLARE_LOCALS
   psdout(10) << "Started advmap" << dendl;
   ps->check_full_transition(advmap.lastmap, advmap.osdmap);
   if (ps->should_restart_peering(
@@ -1133,7 +1142,7 @@ boost::statechart::result PeeringState::Started::react(const QueryState& q)
 void PeeringState::Started::exit()
 {
   context< PeeringMachine >().log_exit(state_name, enter_time);
-  PeeringListener *pl = context< PeeringMachine >().pl;
+  DECLARE_LOCALS
   utime_t dur = ceph_clock_now() - enter_time;
   pl->get_peering_perf().tinc(rs_started_latency, dur);
 }
@@ -1144,7 +1153,7 @@ PeeringState::Reset::Reset(my_context ctx)
     NamedState(context< PeeringMachine >().state_history, "Reset")
 {
   context< PeeringMachine >().log_enter(state_name);
-  PeeringState *ps = context< PeeringMachine >().state;
+  DECLARE_LOCALS
 
   ps->flushes_in_progress = 0;
   ps->set_last_peering_reset();
@@ -1160,7 +1169,7 @@ PeeringState::Reset::react(const IntervalFlush&)
 
 boost::statechart::result PeeringState::Reset::react(const AdvMap& advmap)
 {
-  PeeringState *ps = context< PeeringMachine >().state;
+  DECLARE_LOCALS
   psdout(10) << "Reset advmap" << dendl;
 
   ps->check_full_transition(advmap.lastmap, advmap.osdmap);
@@ -1187,7 +1196,7 @@ boost::statechart::result PeeringState::Reset::react(const AdvMap& advmap)
 
 boost::statechart::result PeeringState::Reset::react(const ActMap&)
 {
-  PeeringState *ps = context< PeeringMachine >().state;
+  DECLARE_LOCALS
   if (ps->should_send_notify() && ps->get_primary().osd >= 0) {
     context< PeeringMachine >().send_notify(
       ps->get_primary(),
@@ -1216,7 +1225,7 @@ boost::statechart::result PeeringState::Reset::react(const QueryState& q)
 void PeeringState::Reset::exit()
 {
   context< PeeringMachine >().log_exit(state_name, enter_time);
-  PeeringListener *pl = context< PeeringMachine >().pl;
+  DECLARE_LOCALS
   utime_t dur = ceph_clock_now() - enter_time;
   pl->get_peering_perf().tinc(rs_reset_latency, dur);
 }
@@ -1228,7 +1237,7 @@ PeeringState::Start::Start(my_context ctx)
 {
   context< PeeringMachine >().log_enter(state_name);
 
-  PeeringState *ps = context< PeeringMachine >().state;
+  DECLARE_LOCALS
   if (ps->is_primary()) {
     psdout(1) << "transitioning to Primary" << dendl;
     post_event(MakePrimary());
@@ -1241,7 +1250,7 @@ PeeringState::Start::Start(my_context ctx)
 void PeeringState::Start::exit()
 {
   context< PeeringMachine >().log_exit(state_name, enter_time);
-  PeeringListener *pl = context< PeeringMachine >().pl;
+  DECLARE_LOCALS
   utime_t dur = ceph_clock_now() - enter_time;
   pl->get_peering_perf().tinc(rs_start_latency, dur);
 }
@@ -1252,7 +1261,7 @@ PeeringState::Primary::Primary(my_context ctx)
     NamedState(context< PeeringMachine >().state_history, "Started/Primary")
 {
   context< PeeringMachine >().log_enter(state_name);
-  PeeringState *ps = context< PeeringMachine >().state;
+  DECLARE_LOCALS
   ceph_assert(ps->want_acting.empty());
 
   // set CREATING bit until we have peered for the first time.
@@ -1277,7 +1286,7 @@ PeeringState::Primary::Primary(my_context ctx)
 
 boost::statechart::result PeeringState::Primary::react(const MNotifyRec& notevt)
 {
-  PeeringState *ps = context< PeeringMachine >().state;
+  DECLARE_LOCALS
   psdout(7) << "handle_pg_notify from osd." << notevt.from << dendl;
   ps->proc_replica_info(
     notevt.from, notevt.notify.info, notevt.notify.epoch_sent);
@@ -1286,7 +1295,7 @@ boost::statechart::result PeeringState::Primary::react(const MNotifyRec& notevt)
 
 boost::statechart::result PeeringState::Primary::react(const ActMap&)
 {
-  PeeringListener *pl = context< PeeringMachine >().pl;
+  DECLARE_LOCALS
   psdout(7) << "handle ActMap primary" << dendl;
   pl->publish_stats_to_osd();
   return discard_event();
@@ -1295,7 +1304,7 @@ boost::statechart::result PeeringState::Primary::react(const ActMap&)
 boost::statechart::result PeeringState::Primary::react(
   const SetForceRecovery&)
 {
-  PeeringState *ps = context< PeeringMachine >().state;
+  DECLARE_LOCALS
   ps->set_force_recovery(true);
   return discard_event();
 }
@@ -1303,7 +1312,7 @@ boost::statechart::result PeeringState::Primary::react(
 boost::statechart::result PeeringState::Primary::react(
   const UnsetForceRecovery&)
 {
-  PeeringState *ps = context< PeeringMachine >().state;
+  DECLARE_LOCALS
   ps->set_force_recovery(false);
   return discard_event();
 }
@@ -1311,8 +1320,7 @@ boost::statechart::result PeeringState::Primary::react(
 boost::statechart::result PeeringState::Primary::react(
   const RequestScrub& evt)
 {
-  PeeringListener *pl = context< PeeringMachine >().pl;
-  PeeringState *ps = context< PeeringMachine >().state;
+  DECLARE_LOCALS
   if (ps->is_primary()) {
     pl->scrub_requested(evt.deep, evt.repair);
     psdout(10) << "marking for scrub" << dendl;
@@ -1323,7 +1331,7 @@ boost::statechart::result PeeringState::Primary::react(
 boost::statechart::result PeeringState::Primary::react(
   const SetForceBackfill&)
 {
-  PeeringState *ps = context< PeeringMachine >().state;
+  DECLARE_LOCALS
   ps->set_force_backfill(true);
   return discard_event();
 }
@@ -1331,7 +1339,7 @@ boost::statechart::result PeeringState::Primary::react(
 boost::statechart::result PeeringState::Primary::react(
   const UnsetForceBackfill&)
 {
-  PeeringState *ps = context< PeeringMachine >().state;
+  DECLARE_LOCALS
   ps->set_force_backfill(false);
   return discard_event();
 }
@@ -1339,8 +1347,7 @@ boost::statechart::result PeeringState::Primary::react(
 void PeeringState::Primary::exit()
 {
   context< PeeringMachine >().log_exit(state_name, enter_time);
-  PeeringState *ps = context< PeeringMachine >().state;
-  PeeringListener *pl = context< PeeringMachine >().pl;
+  DECLARE_LOCALS
   ps->want_acting.clear();
   utime_t dur = ceph_clock_now() - enter_time;
   pl->get_peering_perf().tinc(rs_primary_latency, dur);
@@ -1355,7 +1362,7 @@ PeeringState::Peering::Peering(my_context ctx)
     history_les_bound(false)
 {
   context< PeeringMachine >().log_enter(state_name);
-  PeeringState *ps = context< PeeringMachine >().state;
+  DECLARE_LOCALS
 
   ceph_assert(!ps->is_peered());
   ceph_assert(!ps->is_peering());
@@ -1365,7 +1372,7 @@ PeeringState::Peering::Peering(my_context ctx)
 
 boost::statechart::result PeeringState::Peering::react(const AdvMap& advmap)
 {
-  PeeringState *ps = context< PeeringMachine >().state;
+  DECLARE_LOCALS
   psdout(10) << "Peering advmap" << dendl;
   if (prior_set.affected_by_map(*(advmap.osdmap), ps->dpp)) {
     psdout(1) << "Peering, affected_by_map, going to Reset" << dendl;
@@ -1380,7 +1387,7 @@ boost::statechart::result PeeringState::Peering::react(const AdvMap& advmap)
 
 boost::statechart::result PeeringState::Peering::react(const QueryState& q)
 {
-  PG *pg = context< PeeringMachine >().pg;
+  DECLARE_LOCALS
 
   q.f->open_object_section("state");
   q.f->dump_string("name", state_name);
@@ -1433,8 +1440,8 @@ boost::statechart::result PeeringState::Peering::react(const QueryState& q)
 
 void PeeringState::Peering::exit()
 {
-  PeeringListener *pl = context< PeeringMachine >().pl;
-  PG *pg = context< PeeringMachine >().pg;
+
+  DECLARE_LOCALS
   psdout(10) << "Leaving Peering" << dendl;
   context< PeeringMachine >().log_exit(state_name, enter_time);
   pg->state_clear(PG_STATE_PEERING);
@@ -1451,9 +1458,9 @@ PeeringState::Backfilling::Backfilling(my_context ctx)
     NamedState(context< PeeringMachine >().state_history, "Started/Primary/Active/Backfilling")
 {
   context< PeeringMachine >().log_enter(state_name);
-  PeeringState *ps = context< PeeringMachine >().state;
-  PeeringListener *pl = context< PeeringMachine >().pl;
-  PG *pg = context< PeeringMachine >().pg;
+
+
+  DECLARE_LOCALS
   ps->backfill_reserved = true;
   pg->queue_recovery();
   ps->state_clear(PG_STATE_BACKFILL_TOOFULL);
@@ -1464,8 +1471,7 @@ PeeringState::Backfilling::Backfilling(my_context ctx)
 
 void PeeringState::Backfilling::backfill_release_reservations()
 {
-  PeeringState *ps = context< PeeringMachine >().state;
-  PeeringListener *pl = context< PeeringMachine >().pl;
+  DECLARE_LOCALS
   pl->cancel_local_background_io_reservation();
   for (set<pg_shard_t>::iterator it = ps->backfill_targets.begin();
        it != ps->backfill_targets.end();
@@ -1483,7 +1489,7 @@ void PeeringState::Backfilling::backfill_release_reservations()
 
 void PeeringState::Backfilling::cancel_backfill()
 {
-  PG *pg = context< PeeringMachine >().pg;
+  DECLARE_LOCALS
   backfill_release_reservations();
   if (!pg->waiting_on_backfill.empty()) {
     pg->waiting_on_backfill.clear();
@@ -1501,8 +1507,8 @@ PeeringState::Backfilling::react(const Backfilled &c)
 boost::statechart::result
 PeeringState::Backfilling::react(const DeferBackfill &c)
 {
-  PeeringListener *pl = context< PeeringMachine >().pl;
-  PeeringState *ps = context< PeeringMachine >().state;
+  DECLARE_LOCALS
+
   psdout(10) << "defer backfill, retry delay " << c.delay << dendl;
   ps->state_set(PG_STATE_BACKFILL_WAIT);
   ps->state_clear(PG_STATE_BACKFILLING);
@@ -1520,7 +1526,7 @@ PeeringState::Backfilling::react(const DeferBackfill &c)
 boost::statechart::result
 PeeringState::Backfilling::react(const UnfoundBackfill &c)
 {
-  PG *pg = context< PeeringMachine >().pg;
+  DECLARE_LOCALS
   psdout(10) << "backfill has unfound, can't continue" << dendl;
   pg->state_set(PG_STATE_BACKFILL_UNFOUND);
   pg->state_clear(PG_STATE_BACKFILLING);
@@ -1531,8 +1537,8 @@ PeeringState::Backfilling::react(const UnfoundBackfill &c)
 boost::statechart::result
 PeeringState::Backfilling::react(const RemoteReservationRevokedTooFull &)
 {
-  PeeringListener *pl = context< PeeringMachine >().pl;
-  PeeringState *ps = context< PeeringMachine >().state;
+  DECLARE_LOCALS
+
   ps->state_set(PG_STATE_BACKFILL_TOOFULL);
   ps->state_clear(PG_STATE_BACKFILLING);
   cancel_backfill();
@@ -1550,7 +1556,7 @@ PeeringState::Backfilling::react(const RemoteReservationRevokedTooFull &)
 boost::statechart::result
 PeeringState::Backfilling::react(const RemoteReservationRevoked &)
 {
-  PG *pg = context< PeeringMachine >().pg;
+  DECLARE_LOCALS
   pg->state_set(PG_STATE_BACKFILL_WAIT);
   cancel_backfill();
   if (pg->needs_backfill()) {
@@ -1564,9 +1570,7 @@ PeeringState::Backfilling::react(const RemoteReservationRevoked &)
 void PeeringState::Backfilling::exit()
 {
   context< PeeringMachine >().log_exit(state_name, enter_time);
-  PeeringListener *pl = context< PeeringMachine >().pl;
-  PeeringState *ps = context< PeeringMachine >().state;
-  PG *pg = context< PeeringMachine >().pg;
+  DECLARE_LOCALS
   ps->backfill_reserved = false;
   pg->backfill_reserving = false;
   ps->state_clear(PG_STATE_BACKFILLING);
@@ -1583,8 +1587,8 @@ PeeringState::WaitRemoteBackfillReserved::WaitRemoteBackfillReserved(my_context
     backfill_osd_it(context< Active >().remote_shards_to_reserve_backfill.begin())
 {
   context< PeeringMachine >().log_enter(state_name);
-  PeeringListener *pl = context< PeeringMachine >().pl;
-  PeeringState *ps = context< PeeringMachine >().state;
+  DECLARE_LOCALS
+
   ps->state_set(PG_STATE_BACKFILL_WAIT);
   pl->publish_stats_to_osd();
   post_event(RemoteBackfillReserved());
@@ -1593,8 +1597,7 @@ PeeringState::WaitRemoteBackfillReserved::WaitRemoteBackfillReserved(my_context
 boost::statechart::result
 PeeringState::WaitRemoteBackfillReserved::react(const RemoteBackfillReserved &evt)
 {
-  PeeringListener *pl = context< PeeringMachine >().pl;
-  PeeringState *ps = context< PeeringMachine >().state;
+  DECLARE_LOCALS
 
   int64_t num_bytes = ps->info.stats.stats.sum.num_bytes;
   psdout(10) << __func__ << " num_bytes " << num_bytes << dendl;
@@ -1623,15 +1626,15 @@ PeeringState::WaitRemoteBackfillReserved::react(const RemoteBackfillReserved &ev
 void PeeringState::WaitRemoteBackfillReserved::exit()
 {
   context< PeeringMachine >().log_exit(state_name, enter_time);
-  PeeringListener *pl = context< PeeringMachine >().pl;
+  DECLARE_LOCALS
+
   utime_t dur = ceph_clock_now() - enter_time;
   pl->get_peering_perf().tinc(rs_waitremotebackfillreserved_latency, dur);
 }
 
 void PeeringState::WaitRemoteBackfillReserved::retry()
 {
-  PeeringState *ps = context< PeeringMachine >().state;
-  PeeringListener *pl = context< PeeringMachine >().pl;
+  DECLARE_LOCALS
   pl->cancel_local_background_io_reservation();
 
   // Send CANCEL to all previously acquired reservations
@@ -1683,8 +1686,8 @@ PeeringState::WaitLocalBackfillReserved::WaitLocalBackfillReserved(my_context ct
     NamedState(context< PeeringMachine >().state_history, "Started/Primary/Active/WaitLocalBackfillReserved")
 {
   context< PeeringMachine >().log_enter(state_name);
-  PeeringListener *pl = context< PeeringMachine >().pl;
-  PeeringState *ps = context< PeeringMachine >().state;
+  DECLARE_LOCALS
+
   ps->state_set(PG_STATE_BACKFILL_WAIT);
   pl->request_local_background_io_reservation(
     ps->get_backfill_priority(),
@@ -1702,7 +1705,7 @@ PeeringState::WaitLocalBackfillReserved::WaitLocalBackfillReserved(my_context ct
 void PeeringState::WaitLocalBackfillReserved::exit()
 {
   context< PeeringMachine >().log_exit(state_name, enter_time);
-  PeeringListener *pl = context< PeeringMachine >().pl;
+  DECLARE_LOCALS
   utime_t dur = ceph_clock_now() - enter_time;
   pl->get_peering_perf().tinc(rs_waitlocalbackfillreserved_latency, dur);
 }
@@ -1713,7 +1716,7 @@ PeeringState::NotBackfilling::NotBackfilling(my_context ctx)
     NamedState(context< PeeringMachine >().state_history, "Started/Primary/Active/NotBackfilling")
 {
   context< PeeringMachine >().log_enter(state_name);
-  PG *pg = context< PeeringMachine >().pg;
+  DECLARE_LOCALS
   pg->state_clear(PG_STATE_REPAIR);
   pg->publish_stats_to_osd();
 }
@@ -1733,8 +1736,8 @@ PeeringState::NotBackfilling::react(const RemoteReservationRejected &evt)
 void PeeringState::NotBackfilling::exit()
 {
   context< PeeringMachine >().log_exit(state_name, enter_time);
-  PeeringListener *pl = context< PeeringMachine >().pl;
-  PG *pg = context< PeeringMachine >().pg;
+
+  DECLARE_LOCALS
   pg->state_clear(PG_STATE_BACKFILL_UNFOUND);
   utime_t dur = ceph_clock_now() - enter_time;
   pl->get_peering_perf().tinc(rs_notbackfilling_latency, dur);
@@ -1746,15 +1749,15 @@ PeeringState::NotRecovering::NotRecovering(my_context ctx)
     NamedState(context< PeeringMachine >().state_history, "Started/Primary/Active/NotRecovering")
 {
   context< PeeringMachine >().log_enter(state_name);
-  PG *pg = context< PeeringMachine >().pg;
+  DECLARE_LOCALS
   pg->publish_stats_to_osd();
 }
 
 void PeeringState::NotRecovering::exit()
 {
   context< PeeringMachine >().log_exit(state_name, enter_time);
-  PeeringListener *pl = context< PeeringMachine >().pl;
-  PG *pg = context< PeeringMachine >().pg;
+
+  DECLARE_LOCALS
   pg->state_clear(PG_STATE_RECOVERY_UNFOUND);
   utime_t dur = ceph_clock_now() - enter_time;
   pl->get_peering_perf().tinc(rs_notrecovering_latency, dur);
@@ -1771,7 +1774,7 @@ PeeringState::RepNotRecovering::RepNotRecovering(my_context ctx)
 boost::statechart::result
 PeeringState::RepNotRecovering::react(const RejectRemoteReservation &evt)
 {
-  PG *pg = context< PeeringMachine >().pg;
+  DECLARE_LOCALS
   pg->reject_reservation();
   post_event(RemoteReservationRejected());
   return discard_event();
@@ -1780,7 +1783,7 @@ PeeringState::RepNotRecovering::react(const RejectRemoteReservation &evt)
 void PeeringState::RepNotRecovering::exit()
 {
   context< PeeringMachine >().log_exit(state_name, enter_time);
-  PeeringListener *pl = context< PeeringMachine >().pl;
+  DECLARE_LOCALS
   utime_t dur = ceph_clock_now() - enter_time;
   pl->get_peering_perf().tinc(rs_repnotrecovering_latency, dur);
 }
@@ -1796,8 +1799,7 @@ PeeringState::RepWaitRecoveryReserved::RepWaitRecoveryReserved(my_context ctx)
 boost::statechart::result
 PeeringState::RepWaitRecoveryReserved::react(const RemoteRecoveryReserved &evt)
 {
-  PeeringState *ps = context< PeeringMachine >().state;
-  PeeringListener *pl = context< PeeringMachine >().pl;
+  DECLARE_LOCALS
   pl->send_cluster_message(
     ps->primary.osd,
     new MRecoveryReserve(
@@ -1812,9 +1814,9 @@ boost::statechart::result
 PeeringState::RepWaitRecoveryReserved::react(
   const RemoteReservationCanceled &evt)
 {
-  PG *pg = context< PeeringMachine >().pg;
+  DECLARE_LOCALS
   pg->clear_reserved_num_bytes();
-  PeeringListener *pl = context< PeeringMachine >().pl;
+
   pl->cancel_remote_recovery_reservation();
   return transit<RepNotRecovering>();
 }
@@ -1822,7 +1824,7 @@ PeeringState::RepWaitRecoveryReserved::react(
 void PeeringState::RepWaitRecoveryReserved::exit()
 {
   context< PeeringMachine >().log_exit(state_name, enter_time);
-  PeeringListener *pl = context< PeeringMachine >().pl;
+  DECLARE_LOCALS
   utime_t dur = ceph_clock_now() - enter_time;
   pl->get_peering_perf().tinc(rs_repwaitrecoveryreserved_latency, dur);
 }
@@ -1846,8 +1848,8 @@ static int64_t pending_backfill(CephContext *cct, int64_t bf_bytes, int64_t loca
 boost::statechart::result
 PeeringState::RepNotRecovering::react(const RequestBackfillPrio &evt)
 {
-  PeeringListener *pl = context< PeeringMachine >().pl;
-  PG *pg = context< PeeringMachine >().pg;
+
+  DECLARE_LOCALS
   // Use tentative_bacfill_full() to make sure enough
   // space is available to handle target bytes from primary.
 
@@ -1931,8 +1933,7 @@ PeeringState::RepNotRecovering::react(const RequestBackfillPrio &evt)
 boost::statechart::result
 PeeringState::RepNotRecovering::react(const RequestRecoveryPrio &evt)
 {
-  PeeringListener *pl = context< PeeringMachine >().pl;
-  PeeringState *ps = context< PeeringMachine >().state;
+  DECLARE_LOCALS
 
   // fall back to a local reckoning of priority of primary doesn't pass one
   // (pre-mimic compat)
@@ -1960,7 +1961,7 @@ PeeringState::RepNotRecovering::react(const RequestRecoveryPrio &evt)
 void PeeringState::RepWaitBackfillReserved::exit()
 {
   context< PeeringMachine >().log_exit(state_name, enter_time);
-  PeeringListener *pl = context< PeeringMachine >().pl;
+  DECLARE_LOCALS
   utime_t dur = ceph_clock_now() - enter_time;
   pl->get_peering_perf().tinc(rs_repwaitbackfillreserved_latency, dur);
 }
@@ -1968,8 +1969,9 @@ void PeeringState::RepWaitBackfillReserved::exit()
 boost::statechart::result
 PeeringState::RepWaitBackfillReserved::react(const RemoteBackfillReserved &evt)
 {
-  PeeringState *ps = context< PeeringMachine >().state;
-  PeeringListener *pl = context< PeeringMachine >().pl;
+  DECLARE_LOCALS
+
+
   pl->send_cluster_message(
       ps->primary.osd,
       new MBackfillReserve(
@@ -1984,7 +1986,7 @@ boost::statechart::result
 PeeringState::RepWaitBackfillReserved::react(
   const RejectRemoteReservation &evt)
 {
-  PG *pg = context< PeeringMachine >().pg;
+  DECLARE_LOCALS
   pg->reject_reservation();
   post_event(RemoteReservationRejected());
   return discard_event();
@@ -1994,9 +1996,9 @@ boost::statechart::result
 PeeringState::RepWaitBackfillReserved::react(
   const RemoteReservationRejected &evt)
 {
-  PG *pg = context< PeeringMachine >().pg;
+  DECLARE_LOCALS
   pg->clear_reserved_num_bytes();
-  PeeringListener *pl = context< PeeringMachine >().pl;
+
   pl->cancel_remote_recovery_reservation();
   return transit<RepNotRecovering>();
 }
@@ -2005,9 +2007,9 @@ boost::statechart::result
 PeeringState::RepWaitBackfillReserved::react(
   const RemoteReservationCanceled &evt)
 {
-  PG *pg = context< PeeringMachine >().pg;
+  DECLARE_LOCALS
   pg->clear_reserved_num_bytes();
-  PeeringListener *pl = context< PeeringMachine >().pl;
+
   pl->cancel_remote_recovery_reservation();
   return transit<RepNotRecovering>();
 }
@@ -2023,9 +2025,9 @@ PeeringState::RepRecovering::RepRecovering(my_context ctx)
 boost::statechart::result
 PeeringState::RepRecovering::react(const RemoteRecoveryPreempted &)
 {
-  PG *pg = context< PeeringMachine >().pg;
-  PeeringState *ps = context< PeeringMachine >().state;
-  PeeringListener *pl = context< PeeringMachine >().pl;
+  DECLARE_LOCALS
+
+
   pg->clear_reserved_num_bytes();
   pl->send_cluster_message(
     ps->primary.osd,
@@ -2040,9 +2042,9 @@ PeeringState::RepRecovering::react(const RemoteRecoveryPreempted &)
 boost::statechart::result
 PeeringState::RepRecovering::react(const BackfillTooFull &)
 {
-  PG *pg = context< PeeringMachine >().pg;
-  PeeringState *ps = context< PeeringMachine >().state;
-  PeeringListener *pl = context< PeeringMachine >().pl;
+  DECLARE_LOCALS
+
+
   pg->clear_reserved_num_bytes();
   pl->send_cluster_message(
     ps->primary.osd,
@@ -2057,9 +2059,9 @@ PeeringState::RepRecovering::react(const BackfillTooFull &)
 boost::statechart::result
 PeeringState::RepRecovering::react(const RemoteBackfillPreempted &)
 {
-  PG *pg = context< PeeringMachine >().pg;
-  PeeringState *ps = context< PeeringMachine >().state;
-  PeeringListener *pl = context< PeeringMachine >().pl;
+  DECLARE_LOCALS
+
+
   pg->clear_reserved_num_bytes();
   pl->send_cluster_message(
     ps->primary.osd,
@@ -2074,9 +2076,9 @@ PeeringState::RepRecovering::react(const RemoteBackfillPreempted &)
 void PeeringState::RepRecovering::exit()
 {
   context< PeeringMachine >().log_exit(state_name, enter_time);
-  PG *pg = context< PeeringMachine >().pg;
+  DECLARE_LOCALS
   pg->clear_reserved_num_bytes();
-  PeeringListener *pl = context< PeeringMachine >().pl;
+
   pl->cancel_remote_recovery_reservation();
   utime_t dur = ceph_clock_now() - enter_time;
   pl->get_peering_perf().tinc(rs_reprecovering_latency, dur);
@@ -2093,7 +2095,7 @@ PeeringState::Activating::Activating(my_context ctx)
 void PeeringState::Activating::exit()
 {
   context< PeeringMachine >().log_exit(state_name, enter_time);
-  PeeringListener *pl = context< PeeringMachine >().pl;
+  DECLARE_LOCALS
   utime_t dur = ceph_clock_now() - enter_time;
   pl->get_peering_perf().tinc(rs_activating_latency, dur);
 }
@@ -2103,8 +2105,7 @@ PeeringState::WaitLocalRecoveryReserved::WaitLocalRecoveryReserved(my_context ct
     NamedState(context< PeeringMachine >().state_history, "Started/Primary/Active/WaitLocalRecoveryReserved")
 {
   context< PeeringMachine >().log_enter(state_name);
-  PeeringListener *pl = context< PeeringMachine >().pl;
-  PeeringState *ps = context< PeeringMachine >().state;
+  DECLARE_LOCALS
 
   // Make sure all nodes that part of the recovery aren't full
   if (!ps->cct->_conf->osd_debug_skip_full_check_in_recovery &&
@@ -2131,8 +2132,7 @@ PeeringState::WaitLocalRecoveryReserved::WaitLocalRecoveryReserved(my_context ct
 boost::statechart::result
 PeeringState::WaitLocalRecoveryReserved::react(const RecoveryTooFull &evt)
 {
-  PeeringState *ps = context< PeeringMachine >().state;
-  PeeringListener *pl = context< PeeringMachine >().pl;
+  DECLARE_LOCALS
   ps->state_set(PG_STATE_RECOVERY_TOOFULL);
   pl->schedule_event_after(
     std::make_shared<PGPeeringEvent>(
@@ -2146,7 +2146,7 @@ PeeringState::WaitLocalRecoveryReserved::react(const RecoveryTooFull &evt)
 void PeeringState::WaitLocalRecoveryReserved::exit()
 {
   context< PeeringMachine >().log_exit(state_name, enter_time);
-  PeeringListener *pl = context< PeeringMachine >().pl;
+  DECLARE_LOCALS
   utime_t dur = ceph_clock_now() - enter_time;
   pl->get_peering_perf().tinc(rs_waitlocalrecoveryreserved_latency, dur);
 }
@@ -2162,8 +2162,7 @@ PeeringState::WaitRemoteRecoveryReserved::WaitRemoteRecoveryReserved(my_context
 
 boost::statechart::result
 PeeringState::WaitRemoteRecoveryReserved::react(const RemoteRecoveryReserved &evt) {
-  PeeringListener *pl = context< PeeringMachine >().pl;
-  PeeringState *ps = context< PeeringMachine >().state;
+  DECLARE_LOCALS
 
   if (remote_recovery_reservation_it !=
       context< Active >().remote_shards_to_reserve_recovery.end()) {
@@ -2187,7 +2186,7 @@ PeeringState::WaitRemoteRecoveryReserved::react(const RemoteRecoveryReserved &ev
 void PeeringState::WaitRemoteRecoveryReserved::exit()
 {
   context< PeeringMachine >().log_exit(state_name, enter_time);
-  PeeringListener *pl = context< PeeringMachine >().pl;
+  DECLARE_LOCALS
   utime_t dur = ceph_clock_now() - enter_time;
   pl->get_peering_perf().tinc(rs_waitremoterecoveryreserved_latency, dur);
 }
@@ -2198,7 +2197,7 @@ PeeringState::Recovering::Recovering(my_context ctx)
 {
   context< PeeringMachine >().log_enter(state_name);
 
-  PG *pg = context< PeeringMachine >().pg;
+  DECLARE_LOCALS
   pg->state_clear(PG_STATE_RECOVERY_WAIT);
   pg->state_clear(PG_STATE_RECOVERY_TOOFULL);
   pg->state_set(PG_STATE_RECOVERING);
@@ -2209,8 +2208,7 @@ PeeringState::Recovering::Recovering(my_context ctx)
 
 void PeeringState::Recovering::release_reservations(bool cancel)
 {
-  PeeringState *ps = context< PeeringMachine >().state;
-  PeeringListener *pl = context< PeeringMachine >().pl;
+  DECLARE_LOCALS
   ceph_assert(cancel || !ps->pg_log.get_missing().have_missing());
 
   // release remote reservations
@@ -2233,8 +2231,7 @@ void PeeringState::Recovering::release_reservations(bool cancel)
 boost::statechart::result
 PeeringState::Recovering::react(const AllReplicasRecovered &evt)
 {
-  PeeringState *ps = context< PeeringMachine >().state;
-  PeeringListener *pl = context< PeeringMachine >().pl;
+  DECLARE_LOCALS
   ps->state_clear(PG_STATE_FORCED_RECOVERY);
   release_reservations();
   pl->cancel_local_background_io_reservation();
@@ -2244,8 +2241,7 @@ PeeringState::Recovering::react(const AllReplicasRecovered &evt)
 boost::statechart::result
 PeeringState::Recovering::react(const RequestBackfill &evt)
 {
-  PeeringState *ps = context< PeeringMachine >().state;
-  PeeringListener *pl = context< PeeringMachine >().pl;
+  DECLARE_LOCALS
 
   release_reservations();
 
@@ -2259,8 +2255,7 @@ PeeringState::Recovering::react(const RequestBackfill &evt)
 boost::statechart::result
 PeeringState::Recovering::react(const DeferRecovery &evt)
 {
-  PeeringState *ps = context< PeeringMachine >().state;
-  PeeringListener *pl = context< PeeringMachine >().pl;
+  DECLARE_LOCALS
   if (!ps->state_test(PG_STATE_RECOVERING)) {
     // we may have finished recovery and have an AllReplicasRecovered
     // event queued to move us to the next state.
@@ -2283,8 +2278,7 @@ PeeringState::Recovering::react(const DeferRecovery &evt)
 boost::statechart::result
 PeeringState::Recovering::react(const UnfoundRecovery &evt)
 {
-  PeeringState *ps = context< PeeringMachine >().state;
-  PeeringListener *pl = context< PeeringMachine >().pl;
+  DECLARE_LOCALS
   psdout(10) << "recovery has unfound, can't continue" << dendl;
   ps->state_set(PG_STATE_RECOVERY_UNFOUND);
   pl->cancel_local_background_io_reservation();
@@ -2295,8 +2289,8 @@ PeeringState::Recovering::react(const UnfoundRecovery &evt)
 void PeeringState::Recovering::exit()
 {
   context< PeeringMachine >().log_exit(state_name, enter_time);
-  PeeringListener *pl = context< PeeringMachine >().pl;
-  PG *pg = context< PeeringMachine >().pg;
+
+  DECLARE_LOCALS
   utime_t dur = ceph_clock_now() - enter_time;
   pg->state_clear(PG_STATE_RECOVERING);
   pl->get_peering_perf().tinc(rs_recovering_latency, dur);
@@ -2310,7 +2304,7 @@ PeeringState::Recovered::Recovered(my_context ctx)
 
   context< PeeringMachine >().log_enter(state_name);
 
-  PG *pg = context< PeeringMachine >().pg;
+  DECLARE_LOCALS
 
   ceph_assert(!pg->needs_recovery());
 
@@ -2340,7 +2334,8 @@ PeeringState::Recovered::Recovered(my_context ctx)
 void PeeringState::Recovered::exit()
 {
   context< PeeringMachine >().log_exit(state_name, enter_time);
-  PeeringListener *pl = context< PeeringMachine >().pl;
+  DECLARE_LOCALS
+
   utime_t dur = ceph_clock_now() - enter_time;
   pl->get_peering_perf().tinc(rs_recovered_latency, dur);
 }
@@ -2351,7 +2346,7 @@ PeeringState::Clean::Clean(my_context ctx)
 {
   context< PeeringMachine >().log_enter(state_name);
 
-  PG *pg = context< PeeringMachine >().pg;
+  DECLARE_LOCALS
 
   if (pg->info.last_complete != pg->info.last_update) {
     ceph_abort();
@@ -2365,8 +2360,8 @@ PeeringState::Clean::Clean(my_context ctx)
 void PeeringState::Clean::exit()
 {
   context< PeeringMachine >().log_exit(state_name, enter_time);
-  PeeringListener *pl = context< PeeringMachine >().pl;
-  PG *pg = context< PeeringMachine >().pg;
+
+  DECLARE_LOCALS
   pg->state_clear(PG_STATE_CLEAN);
   utime_t dur = ceph_clock_now() - enter_time;
   pl->get_peering_perf().tinc(rs_clean_latency, dur);
@@ -2404,8 +2399,8 @@ PeeringState::Active::Active(my_context ctx)
 {
   context< PeeringMachine >().log_enter(state_name);
 
-  PeeringState *ps = context< PeeringMachine >().state;
-  PG *pg = context< PeeringMachine >().pg;
+
+  DECLARE_LOCALS
 
   ceph_assert(!ps->backfill_reserved);
   ceph_assert(pg->is_primary());
@@ -2432,8 +2427,8 @@ PeeringState::Active::Active(my_context ctx)
 
 boost::statechart::result PeeringState::Active::react(const AdvMap& advmap)
 {
-  PG *pg = context< PeeringMachine >().pg;
-  PeeringState *ps = context< PeeringMachine >().state;
+  DECLARE_LOCALS
+
   if (ps->should_restart_peering(
        advmap.up_primary,
        advmap.acting_primary,
@@ -2571,7 +2566,7 @@ boost::statechart::result PeeringState::Active::react(const AdvMap& advmap)
 
 boost::statechart::result PeeringState::Active::react(const ActMap&)
 {
-  PG *pg = context< PeeringMachine >().pg;
+  DECLARE_LOCALS
   psdout(10) << "Active: handling ActMap" << dendl;
   ceph_assert(pg->is_primary());
 
@@ -2612,8 +2607,8 @@ boost::statechart::result PeeringState::Active::react(const ActMap&)
 
 boost::statechart::result PeeringState::Active::react(const MNotifyRec& notevt)
 {
-  PeeringState *ps = context< PeeringMachine >().state;
-  PG *pg = context< PeeringMachine >().pg;
+
+  DECLARE_LOCALS
   ceph_assert(pg->is_primary());
   if (pg->peer_info.count(notevt.from)) {
     psdout(10) << "Active: got notify from " << notevt.from
@@ -2638,7 +2633,7 @@ boost::statechart::result PeeringState::Active::react(const MNotifyRec& notevt)
 
 boost::statechart::result PeeringState::Active::react(const MTrim& trim)
 {
-  PG *pg = context< PeeringMachine >().pg;
+  DECLARE_LOCALS
   ceph_assert(pg->is_primary());
 
   // peer is informing us of their last_complete_ondisk
@@ -2652,7 +2647,7 @@ boost::statechart::result PeeringState::Active::react(const MTrim& trim)
 
 boost::statechart::result PeeringState::Active::react(const MInfoRec& infoevt)
 {
-  PG *pg = context< PeeringMachine >().pg;
+  DECLARE_LOCALS
   ceph_assert(pg->is_primary());
 
   ceph_assert(!pg->acting_recovery_backfill.empty());
@@ -2675,7 +2670,7 @@ boost::statechart::result PeeringState::Active::react(const MInfoRec& infoevt)
 
 boost::statechart::result PeeringState::Active::react(const MLogRec& logevt)
 {
-  PG *pg = context< PeeringMachine >().pg;
+  DECLARE_LOCALS
   psdout(10) << "searching osd." << logevt.from
                     << " log for unfound items" << dendl;
   pg->proc_replica_log(
@@ -2694,7 +2689,7 @@ boost::statechart::result PeeringState::Active::react(const MLogRec& logevt)
 
 boost::statechart::result PeeringState::Active::react(const QueryState& q)
 {
-  PG *pg = context< PeeringMachine >().pg;
+  DECLARE_LOCALS
 
   q.f->open_object_section("state");
   q.f->dump_string("name", state_name);
@@ -2732,8 +2727,8 @@ boost::statechart::result PeeringState::Active::react(const QueryState& q)
 
 boost::statechart::result PeeringState::Active::react(const AllReplicasActivated &evt)
 {
-  PeeringState *ps = context< PeeringMachine >().state;
-  PG *pg = context< PeeringMachine >().pg;
+
+  DECLARE_LOCALS
   pg_t pgid = context< PeeringMachine >().spgid.pgid;
 
   all_replicas_activated = true;
@@ -2796,9 +2791,9 @@ boost::statechart::result PeeringState::Active::react(const AllReplicasActivated
 void PeeringState::Active::exit()
 {
   context< PeeringMachine >().log_exit(state_name, enter_time);
-  PeeringListener *pl = context< PeeringMachine >().pl;
-  PeeringState *ps = context< PeeringMachine >().state;
-  PG *pg = context< PeeringMachine >().pg;
+
+
+  DECLARE_LOCALS
   pl->cancel_local_background_io_reservation();
 
   pg->blocked_by.clear();
@@ -2823,14 +2818,14 @@ PeeringState::ReplicaActive::ReplicaActive(my_context ctx)
 {
   context< PeeringMachine >().log_enter(state_name);
 
-  PeeringState *ps = context< PeeringMachine >().state;
+  DECLARE_LOCALS
   ps->start_flush(context< PeeringMachine >().get_cur_transaction());
 }
 
 
 boost::statechart::result PeeringState::ReplicaActive::react(
   const Activate& actevt) {
-  PG *pg = context< PeeringMachine >().pg;
+  DECLARE_LOCALS
   psdout(10) << "In ReplicaActive, about to call activate" << dendl;
   map<int, map<spg_t, pg_query_t> > query_map;
   pg->activate(*context< PeeringMachine >().get_cur_transaction(),
@@ -2842,7 +2837,7 @@ boost::statechart::result PeeringState::ReplicaActive::react(
 
 boost::statechart::result PeeringState::ReplicaActive::react(const MInfoRec& infoevt)
 {
-  PG *pg = context< PeeringMachine >().pg;
+  DECLARE_LOCALS
   pg->proc_primary_info(*context<PeeringMachine>().get_cur_transaction(),
                        infoevt.info);
   return discard_event();
@@ -2850,7 +2845,7 @@ boost::statechart::result PeeringState::ReplicaActive::react(const MInfoRec& inf
 
 boost::statechart::result PeeringState::ReplicaActive::react(const MLogRec& logevt)
 {
-  PG *pg = context< PeeringMachine >().pg;
+  DECLARE_LOCALS
   psdout(10) << "received log from " << logevt.from << dendl;
   ObjectStore::Transaction* t = context<PeeringMachine>().get_cur_transaction();
   pg->merge_log(*t, logevt.msg->info, logevt.msg->log, logevt.from);
@@ -2861,7 +2856,7 @@ boost::statechart::result PeeringState::ReplicaActive::react(const MLogRec& loge
 
 boost::statechart::result PeeringState::ReplicaActive::react(const MTrim& trim)
 {
-  PG *pg = context< PeeringMachine >().pg;
+  DECLARE_LOCALS
   // primary is instructing us to trim
   pg->pg_log.trim(trim.trim_to, pg->info);
   pg->dirty_info = true;
@@ -2870,7 +2865,7 @@ boost::statechart::result PeeringState::ReplicaActive::react(const MTrim& trim)
 
 boost::statechart::result PeeringState::ReplicaActive::react(const ActMap&)
 {
-  PG *pg = context< PeeringMachine >().pg;
+  DECLARE_LOCALS
   if (pg->should_send_notify() && pg->get_primary().osd >= 0) {
     context< PeeringMachine >().send_notify(
       pg->get_primary(),
@@ -2887,7 +2882,7 @@ boost::statechart::result PeeringState::ReplicaActive::react(const ActMap&)
 boost::statechart::result PeeringState::ReplicaActive::react(
   const MQuery& query)
 {
-  PG *pg = context< PeeringMachine >().pg;
+  DECLARE_LOCALS
   pg->fulfill_query(query, context<PeeringMachine>().get_recovery_ctx());
   return discard_event();
 }
@@ -2904,9 +2899,9 @@ boost::statechart::result PeeringState::ReplicaActive::react(const QueryState& q
 void PeeringState::ReplicaActive::exit()
 {
   context< PeeringMachine >().log_exit(state_name, enter_time);
-  PG *pg = context< PeeringMachine >().pg;
+  DECLARE_LOCALS
   pg->clear_reserved_num_bytes();
-  PeeringListener *pl = context< PeeringMachine >().pl;
+
   pl->cancel_remote_recovery_reservation();
   utime_t dur = ceph_clock_now() - enter_time;
   pl->get_peering_perf().tinc(rs_replicaactive_latency, dur);
@@ -2919,8 +2914,8 @@ PeeringState::Stray::Stray(my_context ctx)
 {
   context< PeeringMachine >().log_enter(state_name);
 
-  PeeringState *ps = context< PeeringMachine >().state;
-  PG *pg = context< PeeringMachine >().pg;
+
+  DECLARE_LOCALS
   ceph_assert(!pg->is_peered());
   ceph_assert(!pg->is_peering());
   ceph_assert(!pg->is_primary());
@@ -2935,7 +2930,7 @@ PeeringState::Stray::Stray(my_context ctx)
 
 boost::statechart::result PeeringState::Stray::react(const MLogRec& logevt)
 {
-  PG *pg = context< PeeringMachine >().pg;
+  DECLARE_LOCALS
   MOSDPGLog *msg = logevt.msg.get();
   psdout(10) << "got info+log from osd." << logevt.from << " " << msg->info << " " << msg->log << dendl;
 
@@ -2963,7 +2958,7 @@ boost::statechart::result PeeringState::Stray::react(const MLogRec& logevt)
 
 boost::statechart::result PeeringState::Stray::react(const MInfoRec& infoevt)
 {
-  PG *pg = context< PeeringMachine >().pg;
+  DECLARE_LOCALS
   psdout(10) << "got info from osd." << infoevt.from << " " << infoevt.info << dendl;
 
   if (pg->info.last_update > infoevt.info.last_update) {
@@ -2983,14 +2978,14 @@ boost::statechart::result PeeringState::Stray::react(const MInfoRec& infoevt)
 
 boost::statechart::result PeeringState::Stray::react(const MQuery& query)
 {
-  PG *pg = context< PeeringMachine >().pg;
+  DECLARE_LOCALS
   pg->fulfill_query(query, context<PeeringMachine>().get_recovery_ctx());
   return discard_event();
 }
 
 boost::statechart::result PeeringState::Stray::react(const ActMap&)
 {
-  PG *pg = context< PeeringMachine >().pg;
+  DECLARE_LOCALS
   if (pg->should_send_notify() && pg->get_primary().osd >= 0) {
     context< PeeringMachine >().send_notify(
       pg->get_primary(),
@@ -3007,7 +3002,7 @@ boost::statechart::result PeeringState::Stray::react(const ActMap&)
 void PeeringState::Stray::exit()
 {
   context< PeeringMachine >().log_exit(state_name, enter_time);
-  PeeringListener *pl = context< PeeringMachine >().pl;
+  DECLARE_LOCALS
   utime_t dur = ceph_clock_now() - enter_time;
   pl->get_peering_perf().tinc(rs_stray_latency, dur);
 }
@@ -3019,18 +3014,18 @@ PeeringState::ToDelete::ToDelete(my_context ctx)
     NamedState(context< PeeringMachine >().state_history, "Started/ToDelete")
 {
   context< PeeringMachine >().log_enter(state_name);
-  PG *pg = context< PeeringMachine >().pg;
+  DECLARE_LOCALS
   pg->osd->logger->inc(l_osd_pg_removing);
 }
 
 void PeeringState::ToDelete::exit()
 {
   context< PeeringMachine >().log_exit(state_name, enter_time);
-  PG *pg = context< PeeringMachine >().pg;
+  DECLARE_LOCALS
   // note: on a successful removal, this path doesn't execute. see
   // _delete_some().
   pg->osd->logger->dec(l_osd_pg_removing);
-  PeeringListener *pl = context< PeeringMachine >().pl;
+
   pl->cancel_local_background_io_reservation();
 }
 
@@ -3041,8 +3036,7 @@ PeeringState::WaitDeleteReserved::WaitDeleteReserved(my_context ctx)
               "Started/ToDelete/WaitDeleteReseved")
 {
   context< PeeringMachine >().log_enter(state_name);
-  PeeringListener *pl = context< PeeringMachine >().pl;
-  PeeringState *ps = context< PeeringMachine >().state;
+  DECLARE_LOCALS
   context< ToDelete >().priority = ps->get_delete_priority();
 
   pl->cancel_local_background_io_reservation();
@@ -3061,7 +3055,7 @@ PeeringState::WaitDeleteReserved::WaitDeleteReserved(my_context ctx)
 boost::statechart::result PeeringState::ToDelete::react(
   const ActMap& evt)
 {
-  PeeringState *ps = context< PeeringMachine >().state;
+  DECLARE_LOCALS
   if (ps->get_delete_priority() != priority) {
     psdout(10) << __func__ << " delete priority changed, resetting"
                   << dendl;
@@ -3081,7 +3075,7 @@ PeeringState::Deleting::Deleting(my_context ctx)
     NamedState(context< PeeringMachine >().state_history, "Started/ToDelete/Deleting")
 {
   context< PeeringMachine >().log_enter(state_name);
-  PG *pg = context< PeeringMachine >().pg;
+  DECLARE_LOCALS
   pg->deleting = true;
   ObjectStore::Transaction* t = context<PeeringMachine>().get_cur_transaction();
   pg->on_removal(t);
@@ -3091,7 +3085,7 @@ PeeringState::Deleting::Deleting(my_context ctx)
 boost::statechart::result PeeringState::Deleting::react(
   const DeleteSome& evt)
 {
-  PG *pg = context< PeeringMachine >().pg;
+  DECLARE_LOCALS
   pg->_delete_some(context<PeeringMachine>().get_cur_transaction());
   return discard_event();
 }
@@ -3099,9 +3093,8 @@ boost::statechart::result PeeringState::Deleting::react(
 void PeeringState::Deleting::exit()
 {
   context< PeeringMachine >().log_exit(state_name, enter_time);
-  PeeringState *ps = context< PeeringMachine >().state;
+  DECLARE_LOCALS
   ps->deleting = false;
-  PeeringListener *pl = context< PeeringMachine >().pl;
   pl->cancel_local_background_io_reservation();
 }
 
@@ -3112,8 +3105,8 @@ PeeringState::GetInfo::GetInfo(my_context ctx)
 {
   context< PeeringMachine >().log_enter(state_name);
 
-  PeeringState *ps = context< PeeringMachine >().state;
-  PG *pg = context< PeeringMachine >().pg;
+
+  DECLARE_LOCALS
   ps->check_past_interval_bounds();
   PastIntervals::PriorSet &prior_set = context< Peering >().prior_set;
 
@@ -3132,7 +3125,7 @@ PeeringState::GetInfo::GetInfo(my_context ctx)
 
 void PeeringState::GetInfo::get_infos()
 {
-  PG *pg = context< PeeringMachine >().pg;
+  DECLARE_LOCALS
   PastIntervals::PriorSet &prior_set = context< Peering >().prior_set;
 
   pg->blocked_by.clear();
@@ -3169,8 +3162,8 @@ void PeeringState::GetInfo::get_infos()
 
 boost::statechart::result PeeringState::GetInfo::react(const MNotifyRec& infoevt)
 {
-  PeeringState *ps = context< PeeringMachine >().state;
-  PG *pg = context< PeeringMachine >().pg;
+
+  DECLARE_LOCALS
 
   set<pg_shard_t>::iterator p = peer_info_requested.find(infoevt.from);
   if (p != peer_info_requested.end()) {
@@ -3218,7 +3211,7 @@ boost::statechart::result PeeringState::GetInfo::react(const MNotifyRec& infoevt
 
 boost::statechart::result PeeringState::GetInfo::react(const QueryState& q)
 {
-  PG *pg = context< PeeringMachine >().pg;
+  DECLARE_LOCALS
   q.f->open_object_section("state");
   q.f->dump_string("name", state_name);
   q.f->dump_stream("enter_time") << enter_time;
@@ -3245,8 +3238,8 @@ boost::statechart::result PeeringState::GetInfo::react(const QueryState& q)
 void PeeringState::GetInfo::exit()
 {
   context< PeeringMachine >().log_exit(state_name, enter_time);
-  PeeringListener *pl = context< PeeringMachine >().pl;
-  PG *pg = context< PeeringMachine >().pg;
+
+  DECLARE_LOCALS
   utime_t dur = ceph_clock_now() - enter_time;
   pl->get_peering_perf().tinc(rs_getinfo_latency, dur);
   pg->blocked_by.clear();
@@ -3262,7 +3255,7 @@ PeeringState::GetLog::GetLog(my_context ctx)
 {
   context< PeeringMachine >().log_enter(state_name);
 
-  PG *pg = context< PeeringMachine >().pg;
+  DECLARE_LOCALS
 
   // adjust acting?
   if (!pg->choose_acting(auth_log_shard, false,
@@ -3351,8 +3344,8 @@ boost::statechart::result PeeringState::GetLog::react(const MLogRec& logevt)
 
 boost::statechart::result PeeringState::GetLog::react(const GotLog&)
 {
-  PeeringState *ps = context< PeeringMachine >().state;
-  PG *pg = context< PeeringMachine >().pg;
+
+  DECLARE_LOCALS
   psdout(10) << "leaving GetLog" << dendl;
   if (msg) {
     psdout(10) << "processing master log" << dendl;
@@ -3377,8 +3370,8 @@ boost::statechart::result PeeringState::GetLog::react(const QueryState& q)
 void PeeringState::GetLog::exit()
 {
   context< PeeringMachine >().log_exit(state_name, enter_time);
-  PeeringListener *pl = context< PeeringMachine >().pl;
-  PG *pg = context< PeeringMachine >().pg;
+
+  DECLARE_LOCALS
   utime_t dur = ceph_clock_now() - enter_time;
   pl->get_peering_perf().tinc(rs_getlog_latency, dur);
   pg->blocked_by.clear();
@@ -3394,7 +3387,7 @@ PeeringState::WaitActingChange::WaitActingChange(my_context ctx)
 
 boost::statechart::result PeeringState::WaitActingChange::react(const AdvMap& advmap)
 {
-  PG *pg = context< PeeringMachine >().pg;
+  DECLARE_LOCALS
   OSDMapRef osdmap = advmap.osdmap;
 
   psdout(10) << "verifying no want_acting " << pg->want_acting << " targets didn't go down" << dendl;
@@ -3439,7 +3432,7 @@ boost::statechart::result PeeringState::WaitActingChange::react(const QueryState
 void PeeringState::WaitActingChange::exit()
 {
   context< PeeringMachine >().log_exit(state_name, enter_time);
-  PeeringListener *pl = context< PeeringMachine >().pl;
+  DECLARE_LOCALS
   utime_t dur = ceph_clock_now() - enter_time;
   pl->get_peering_perf().tinc(rs_waitactingchange_latency, dur);
 }
@@ -3450,7 +3443,7 @@ PeeringState::Down::Down(my_context ctx)
     NamedState(context< PeeringMachine >().state_history, "Started/Primary/Peering/Down")
 {
   context< PeeringMachine >().log_enter(state_name);
-  PG *pg = context< PeeringMachine >().pg;
+  DECLARE_LOCALS
 
   pg->state_clear(PG_STATE_PEERING);
   pg->state_set(PG_STATE_DOWN);
@@ -3464,8 +3457,8 @@ PeeringState::Down::Down(my_context ctx)
 void PeeringState::Down::exit()
 {
   context< PeeringMachine >().log_exit(state_name, enter_time);
-  PeeringListener *pl = context< PeeringMachine >().pl;
-  PG *pg = context< PeeringMachine >().pg;
+
+  DECLARE_LOCALS
 
   pg->state_clear(PG_STATE_DOWN);
   utime_t dur = ceph_clock_now() - enter_time;
@@ -3487,7 +3480,7 @@ boost::statechart::result PeeringState::Down::react(const QueryState& q)
 
 boost::statechart::result PeeringState::Down::react(const MNotifyRec& infoevt)
 {
-  PG *pg = context< PeeringMachine >().pg;
+  DECLARE_LOCALS
 
   ceph_assert(pg->is_primary());
   epoch_t old_start = pg->info.history.last_epoch_started;
@@ -3513,7 +3506,7 @@ PeeringState::Incomplete::Incomplete(my_context ctx)
     NamedState(context< PeeringMachine >().state_history, "Started/Primary/Peering/Incomplete")
 {
   context< PeeringMachine >().log_enter(state_name);
-  PG *pg = context< PeeringMachine >().pg;
+  DECLARE_LOCALS
 
   pg->state_clear(PG_STATE_PEERING);
   pg->state_set(PG_STATE_INCOMPLETE);
@@ -3525,7 +3518,7 @@ PeeringState::Incomplete::Incomplete(my_context ctx)
 }
 
 boost::statechart::result PeeringState::Incomplete::react(const AdvMap &advmap) {
-  PG *pg = context< PeeringMachine >().pg;
+  DECLARE_LOCALS
   int64_t poolnum = pg->info.pgid.pool();
 
   // Reset if min_size turn smaller than previous value, pg might now be able to go active
@@ -3540,7 +3533,7 @@ boost::statechart::result PeeringState::Incomplete::react(const AdvMap &advmap)
 }
 
 boost::statechart::result PeeringState::Incomplete::react(const MNotifyRec& notevt) {
-  PeeringState *ps = context< PeeringMachine >().state;
+  DECLARE_LOCALS
   psdout(7) << "handle_pg_notify from osd." << notevt.from << dendl;
   if (ps->proc_replica_info(
     notevt.from, notevt.notify.info, notevt.notify.epoch_sent)) {
@@ -3565,8 +3558,8 @@ boost::statechart::result PeeringState::Incomplete::react(
 void PeeringState::Incomplete::exit()
 {
   context< PeeringMachine >().log_exit(state_name, enter_time);
-  PeeringListener *pl = context< PeeringMachine >().pl;
-  PG *pg = context< PeeringMachine >().pg;
+
+  DECLARE_LOCALS
 
   pg->state_clear(PG_STATE_INCOMPLETE);
   utime_t dur = ceph_clock_now() - enter_time;
@@ -3582,7 +3575,7 @@ PeeringState::GetMissing::GetMissing(my_context ctx)
 {
   context< PeeringMachine >().log_enter(state_name);
 
-  PG *pg = context< PeeringMachine >().pg;
+  DECLARE_LOCALS
   ceph_assert(!pg->acting_recovery_backfill.empty());
   eversion_t since;
   for (set<pg_shard_t>::iterator i = pg->acting_recovery_backfill.begin();
@@ -3665,7 +3658,7 @@ PeeringState::GetMissing::GetMissing(my_context ctx)
 
 boost::statechart::result PeeringState::GetMissing::react(const MLogRec& logevt)
 {
-  PG *pg = context< PeeringMachine >().pg;
+  DECLARE_LOCALS
 
   peer_missing_requested.erase(logevt.from);
   pg->proc_replica_log(logevt.msg->info, logevt.msg->log, logevt.msg->missing, logevt.from);
@@ -3686,7 +3679,7 @@ boost::statechart::result PeeringState::GetMissing::react(const MLogRec& logevt)
 
 boost::statechart::result PeeringState::GetMissing::react(const QueryState& q)
 {
-  PG *pg = context< PeeringMachine >().pg;
+  DECLARE_LOCALS
   q.f->open_object_section("state");
   q.f->dump_string("name", state_name);
   q.f->dump_stream("enter_time") << enter_time;
@@ -3713,8 +3706,8 @@ boost::statechart::result PeeringState::GetMissing::react(const QueryState& q)
 void PeeringState::GetMissing::exit()
 {
   context< PeeringMachine >().log_exit(state_name, enter_time);
-  PeeringListener *pl = context< PeeringMachine >().pl;
-  PG *pg = context< PeeringMachine >().pg;
+
+  DECLARE_LOCALS
   utime_t dur = ceph_clock_now() - enter_time;
   pl->get_peering_perf().tinc(rs_getmissing_latency, dur);
   pg->blocked_by.clear();
@@ -3730,7 +3723,7 @@ PeeringState::WaitUpThru::WaitUpThru(my_context ctx)
 
 boost::statechart::result PeeringState::WaitUpThru::react(const ActMap& am)
 {
-  PG *pg = context< PeeringMachine >().pg;
+  DECLARE_LOCALS
   if (!pg->need_up_thru) {
     post_event(Activate(pg->get_osdmap_epoch()));
   }
@@ -3739,7 +3732,7 @@ boost::statechart::result PeeringState::WaitUpThru::react(const ActMap& am)
 
 boost::statechart::result PeeringState::WaitUpThru::react(const MLogRec& logevt)
 {
-  PG *pg = context< PeeringMachine >().pg;
+  DECLARE_LOCALS
   psdout(10) << "Noting missing from osd." << logevt.from << dendl;
   pg->peer_missing[logevt.from].claim(logevt.msg->missing);
   pg->peer_info[logevt.from] = logevt.msg->info;
@@ -3759,7 +3752,7 @@ boost::statechart::result PeeringState::WaitUpThru::react(const QueryState& q)
 void PeeringState::WaitUpThru::exit()
 {
   context< PeeringMachine >().log_exit(state_name, enter_time);
-  PeeringListener *pl = context< PeeringMachine >().pl;
+  DECLARE_LOCALS
   utime_t dur = ceph_clock_now() - enter_time;
   pl->get_peering_perf().tinc(rs_waitupthru_latency, dur);
 }
@@ -3770,15 +3763,15 @@ void PeeringState::WaitUpThru::exit()
 
 void PeeringState::PeeringMachine::log_enter(const char *state_name)
 {
-  PG *pg = context< PeeringMachine >().pg;
+  DECLARE_LOCALS
   psdout(5) << "enter " << state_name << dendl;
   pg->osd->pg_recovery_stats.log_enter(state_name);
 }
 
 void PeeringState::PeeringMachine::log_exit(const char *state_name, utime_t enter_time)
 {
+  DECLARE_LOCALS
   utime_t dur = ceph_clock_now() - enter_time;
-  PG *pg = context< PeeringMachine >().pg;
   psdout(5) << "exit " << state_name << " " << dur << " " << event_count << " " << event_time << dendl;
   pg->osd->pg_recovery_stats.log_exit(state_name, ceph_clock_now() - enter_time,
                                      event_count, event_time);