From b7e77996586daa46da6be0bfbb8c2b93e203a83a Mon Sep 17 00:00:00 2001 From: Brad Hubbard Date: Wed, 15 Mar 2017 07:56:29 +1000 Subject: [PATCH] osd: Implement peering state timing Gather a history of peering states and time spent within them. Signed-off-by: Brad Hubbard --- src/osd/OSD.cc | 19 ++++++ src/osd/PG.cc | 125 ++++++++++++++++++++++++++++++---------- src/osd/PG.h | 70 ++++++++++++++++++++-- src/osd/PrimaryLogPG.cc | 4 +- src/osd/PrimaryLogPG.h | 12 ++-- 5 files changed, 185 insertions(+), 45 deletions(-) diff --git a/src/osd/OSD.cc b/src/osd/OSD.cc index 0bb92709223..3dabdc0317b 100644 --- a/src/osd/OSD.cc +++ b/src/osd/OSD.cc @@ -2117,6 +2117,20 @@ bool OSD::asok_command(string admin_command, cmdmap_t& cmdmap, string format, store->generate_db_histogram(f); } else if (admin_command == "flush_store_cache") { store->flush_cache(); + } else if (admin_command == "dump_pgstate_history") { + f->open_object_section("pgstate_history"); + RWLock::RLocker l2(pg_map_lock); + for (ceph::unordered_map::iterator it = pg_map.begin(); + it != pg_map.end(); + ++it) { + + PG *pg = it->second; + f->dump_stream("pg") << pg->get_pgid(); + pg->lock(); + pg->pgstate_history.dump(f); + pg->unlock(); + } + f->close_section(); } else { assert(0 == "broken asok registration"); } @@ -2627,6 +2641,10 @@ void OSD::final_init() asok_hook, "Flush bluestore internal cache"); assert(r == 0); + r = admin_socket->register_command("dump_pgstate_history", "dump_pgstate_history", + asok_hook, + "show recent state history"); + assert(r == 0); test_ops_hook = new TestOpsSocketHook(&(this->service), this->store); // Note: pools are CephString instead of CephPoolname because @@ -3001,6 +3019,7 @@ int OSD::shutdown() cct->get_admin_socket()->unregister_command("dump_objectstore_kv_stats"); cct->get_admin_socket()->unregister_command("calc_objectstore_db_histogram"); cct->get_admin_socket()->unregister_command("flush_store_cache"); + cct->get_admin_socket()->unregister_command("dump_pgstate_history"); delete asok_hook; asok_hook = NULL; diff --git a/src/osd/PG.cc b/src/osd/PG.cc index f8c14131f6d..630ba1d79e6 100644 --- a/src/osd/PG.cc +++ b/src/osd/PG.cc @@ -92,6 +92,66 @@ static ostream& _prefix(std::ostream *_dout, T *t) MEMPOOL_DEFINE_OBJECT_FACTORY(PG::CephPeeringEvt, pg_peering_evt, osd); +void PGStateHistory::enter(PG* pg, const utime_t entime, const char* state) +{ + // Ignore trimming state machine for now + if (::strstr(state, "Trimming") != NULL) { + return; + } else if (pi != nullptr) { + pi->enter_state(entime, state); + } else { + // Store current state since we can't reliably take the PG lock here + if ( tmppi == nullptr) { + tmppi = std::unique_ptr(new PGStateInstance); + } + + thispg = pg; + tmppi->enter_state(entime, state); + } +} + +void PGStateHistory::exit(const char* state) { + // Ignore trimming state machine for now + // Do nothing if PG is being destroyed! + if (::strstr(state, "Trimming") != NULL || pg_in_destructor) { + return; + } else { + bool ilocked = false; + if(!thispg->is_locked()) { + thispg->lock(); + ilocked = true; + } + if (pi == nullptr) { + buffer.push_back(std::unique_ptr(tmppi.release())); + pi = buffer.back().get(); + pi->setepoch(thispg->get_osdmap()->get_epoch()); + } + + pi->exit_state(ceph_clock_now()); + if (::strcmp(state, "Reset") == 0) { + this->reset(); + } + if(ilocked) { + thispg->unlock(); + } + } +} + +void PGStateHistory::dump(Formatter* f) const { + f->open_array_section("history"); + for (auto pi = buffer.begin(); pi != buffer.end(); ++pi) { + f->open_object_section("states"); + f->dump_stream("epoch") << (*pi)->this_epoch; + for (auto she : (*pi)->state_history) { + f->dump_string("state", std::get<2>(she)); + f->dump_stream("enter") << std::get<0>(she); + f->dump_stream("exit") << std::get<1>(she); + } + f->close_section(); + } + f->close_section(); +} + void PG::get(const char* tag) { ref++; @@ -271,6 +331,7 @@ PG::PG(OSDService *o, OSDMapRef curmap, PG::~PG() { + pgstate_history.set_pg_in_destructor(); #ifdef PG_DEBUG_REFS osd->remove_pgid(info.pgid, this); #endif @@ -5901,7 +5962,7 @@ std::ostream& operator<<(std::ostream& oss, /*------Crashed-------*/ PG::RecoveryState::Crashed::Crashed(my_context ctx) : my_base(ctx), - NamedState(context< RecoveryMachine >().pg->cct, "Crashed") + NamedState(context< RecoveryMachine >().pg, "Crashed") { context< RecoveryMachine >().log_enter(state_name); assert(0 == "we got a bad state machine event"); @@ -5911,7 +5972,7 @@ PG::RecoveryState::Crashed::Crashed(my_context ctx) /*------Initial-------*/ PG::RecoveryState::Initial::Initial(my_context ctx) : my_base(ctx), - NamedState(context< RecoveryMachine >().pg->cct, "Initial") + NamedState(context< RecoveryMachine >().pg, "Initial") { context< RecoveryMachine >().log_enter(state_name); } @@ -5965,7 +6026,7 @@ void PG::RecoveryState::Initial::exit() /*------Started-------*/ PG::RecoveryState::Started::Started(my_context ctx) : my_base(ctx), - NamedState(context< RecoveryMachine >().pg->cct, "Started") + NamedState(context< RecoveryMachine >().pg, "Started") { context< RecoveryMachine >().log_enter(state_name); } @@ -6030,7 +6091,7 @@ void PG::RecoveryState::Started::exit() /*--------Reset---------*/ PG::RecoveryState::Reset::Reset(my_context ctx) : my_base(ctx), - NamedState(context< RecoveryMachine >().pg->cct, "Reset") + NamedState(context< RecoveryMachine >().pg, "Reset") { context< RecoveryMachine >().log_enter(state_name); PG *pg = context< RecoveryMachine >().pg; @@ -6126,7 +6187,7 @@ void PG::RecoveryState::Reset::exit() /*-------Start---------*/ PG::RecoveryState::Start::Start(my_context ctx) : my_base(ctx), - NamedState(context< RecoveryMachine >().pg->cct, "Start") + NamedState(context< RecoveryMachine >().pg, "Start") { context< RecoveryMachine >().log_enter(state_name); @@ -6151,7 +6212,7 @@ void PG::RecoveryState::Start::exit() /*---------Primary--------*/ PG::RecoveryState::Primary::Primary(my_context ctx) : my_base(ctx), - NamedState(context< RecoveryMachine >().pg->cct, "Started/Primary") + NamedState(context< RecoveryMachine >().pg, "Started/Primary") { context< RecoveryMachine >().log_enter(state_name); PG *pg = context< RecoveryMachine >().pg; @@ -6209,7 +6270,7 @@ void PG::RecoveryState::Primary::exit() /*---------Peering--------*/ PG::RecoveryState::Peering::Peering(my_context ctx) : my_base(ctx), - NamedState(context< RecoveryMachine >().pg->cct, "Started/Primary/Peering"), + NamedState(context< RecoveryMachine >().pg, "Started/Primary/Peering"), history_les_bound(false) { context< RecoveryMachine >().log_enter(state_name); @@ -6311,7 +6372,7 @@ void PG::RecoveryState::Peering::exit() /*------Backfilling-------*/ PG::RecoveryState::Backfilling::Backfilling(my_context ctx) : my_base(ctx), - NamedState(context< RecoveryMachine >().pg->cct, "Started/Primary/Active/Backfilling") + NamedState(context< RecoveryMachine >().pg, "Started/Primary/Active/Backfilling") { context< RecoveryMachine >().log_enter(state_name); PG *pg = context< RecoveryMachine >().pg; @@ -6368,7 +6429,7 @@ void PG::RecoveryState::Backfilling::exit() PG::RecoveryState::WaitRemoteBackfillReserved::WaitRemoteBackfillReserved(my_context ctx) : my_base(ctx), - NamedState(context< RecoveryMachine >().pg->cct, "Started/Primary/Active/WaitRemoteBackfillReserved"), + NamedState(context< RecoveryMachine >().pg, "Started/Primary/Active/WaitRemoteBackfillReserved"), backfill_osd_it(context< Active >().remote_shards_to_reserve_backfill.begin()) { context< RecoveryMachine >().log_enter(state_name); @@ -6450,7 +6511,7 @@ PG::RecoveryState::WaitRemoteBackfillReserved::react(const RemoteReservationReje /*--WaitLocalBackfillReserved--*/ PG::RecoveryState::WaitLocalBackfillReserved::WaitLocalBackfillReserved(my_context ctx) : my_base(ctx), - NamedState(context< RecoveryMachine >().pg->cct, "Started/Primary/Active/WaitLocalBackfillReserved") + NamedState(context< RecoveryMachine >().pg, "Started/Primary/Active/WaitLocalBackfillReserved") { context< RecoveryMachine >().log_enter(state_name); PG *pg = context< RecoveryMachine >().pg; @@ -6475,7 +6536,7 @@ void PG::RecoveryState::WaitLocalBackfillReserved::exit() /*----NotBackfilling------*/ PG::RecoveryState::NotBackfilling::NotBackfilling(my_context ctx) : my_base(ctx), - NamedState(context< RecoveryMachine >().pg->cct, "Started/Primary/Active/NotBackfilling") + NamedState(context< RecoveryMachine >().pg, "Started/Primary/Active/NotBackfilling") { context< RecoveryMachine >().log_enter(state_name); PG *pg = context< RecoveryMachine >().pg; @@ -6505,7 +6566,7 @@ void PG::RecoveryState::NotBackfilling::exit() /*----NotRecovering------*/ PG::RecoveryState::NotRecovering::NotRecovering(my_context ctx) : my_base(ctx), - NamedState(context< RecoveryMachine >().pg->cct, "Started/Primary/Active/NotRecovering") + NamedState(context< RecoveryMachine >().pg, "Started/Primary/Active/NotRecovering") { context< RecoveryMachine >().log_enter(state_name); PG *pg = context< RecoveryMachine >().pg; @@ -6523,7 +6584,7 @@ void PG::RecoveryState::NotRecovering::exit() /*---RepNotRecovering----*/ PG::RecoveryState::RepNotRecovering::RepNotRecovering(my_context ctx) : my_base(ctx), - NamedState(context< RecoveryMachine >().pg->cct, "Started/ReplicaActive/RepNotRecovering") + NamedState(context< RecoveryMachine >().pg, "Started/ReplicaActive/RepNotRecovering") { context< RecoveryMachine >().log_enter(state_name); } @@ -6539,7 +6600,7 @@ void PG::RecoveryState::RepNotRecovering::exit() /*---RepWaitRecoveryReserved--*/ PG::RecoveryState::RepWaitRecoveryReserved::RepWaitRecoveryReserved(my_context ctx) : my_base(ctx), - NamedState(context< RecoveryMachine >().pg->cct, "Started/ReplicaActive/RepWaitRecoveryReserved") + NamedState(context< RecoveryMachine >().pg, "Started/ReplicaActive/RepWaitRecoveryReserved") { context< RecoveryMachine >().log_enter(state_name); PG *pg = context< RecoveryMachine >().pg; @@ -6577,7 +6638,7 @@ void PG::RecoveryState::RepWaitRecoveryReserved::exit() /*-RepWaitBackfillReserved*/ PG::RecoveryState::RepWaitBackfillReserved::RepWaitBackfillReserved(my_context ctx) : my_base(ctx), - NamedState(context< RecoveryMachine >().pg->cct, "Started/ReplicaActive/RepWaitBackfillReserved") + NamedState(context< RecoveryMachine >().pg, "Started/ReplicaActive/RepWaitBackfillReserved") { context< RecoveryMachine >().log_enter(state_name); } @@ -6659,7 +6720,7 @@ PG::RecoveryState::RepWaitBackfillReserved::react(const RemoteReservationRejecte /*---RepRecovering-------*/ PG::RecoveryState::RepRecovering::RepRecovering(my_context ctx) : my_base(ctx), - NamedState(context< RecoveryMachine >().pg->cct, "Started/ReplicaActive/RepRecovering") + NamedState(context< RecoveryMachine >().pg, "Started/ReplicaActive/RepRecovering") { context< RecoveryMachine >().log_enter(state_name); } @@ -6684,7 +6745,7 @@ void PG::RecoveryState::RepRecovering::exit() /*------Activating--------*/ PG::RecoveryState::Activating::Activating(my_context ctx) : my_base(ctx), - NamedState(context< RecoveryMachine >().pg->cct, "Started/Primary/Active/Activating") + NamedState(context< RecoveryMachine >().pg, "Started/Primary/Active/Activating") { context< RecoveryMachine >().log_enter(state_name); } @@ -6699,7 +6760,7 @@ void PG::RecoveryState::Activating::exit() PG::RecoveryState::WaitLocalRecoveryReserved::WaitLocalRecoveryReserved(my_context ctx) : my_base(ctx), - NamedState(context< RecoveryMachine >().pg->cct, "Started/Primary/Active/WaitLocalRecoveryReserved") + NamedState(context< RecoveryMachine >().pg, "Started/Primary/Active/WaitLocalRecoveryReserved") { context< RecoveryMachine >().log_enter(state_name); PG *pg = context< RecoveryMachine >().pg; @@ -6741,7 +6802,7 @@ void PG::RecoveryState::WaitLocalRecoveryReserved::exit() PG::RecoveryState::WaitRemoteRecoveryReserved::WaitRemoteRecoveryReserved(my_context ctx) : my_base(ctx), - NamedState(context< RecoveryMachine >().pg->cct, "Started/Primary/Active/WaitRemoteRecoveryReserved"), + NamedState(context< RecoveryMachine >().pg, "Started/Primary/Active/WaitRemoteRecoveryReserved"), remote_recovery_reservation_it(context< Active >().remote_shards_to_reserve_recovery.begin()) { context< RecoveryMachine >().log_enter(state_name); @@ -6781,7 +6842,7 @@ void PG::RecoveryState::WaitRemoteRecoveryReserved::exit() PG::RecoveryState::Recovering::Recovering(my_context ctx) : my_base(ctx), - NamedState(context< RecoveryMachine >().pg->cct, "Started/Primary/Active/Recovering") + NamedState(context< RecoveryMachine >().pg, "Started/Primary/Active/Recovering") { context< RecoveryMachine >().log_enter(state_name); @@ -6846,7 +6907,7 @@ void PG::RecoveryState::Recovering::exit() PG::RecoveryState::Recovered::Recovered(my_context ctx) : my_base(ctx), - NamedState(context< RecoveryMachine >().pg->cct, "Started/Primary/Active/Recovered") + NamedState(context< RecoveryMachine >().pg, "Started/Primary/Active/Recovered") { pg_shard_t auth_log_shard; @@ -6886,7 +6947,7 @@ void PG::RecoveryState::Recovered::exit() PG::RecoveryState::Clean::Clean(my_context ctx) : my_base(ctx), - NamedState(context< RecoveryMachine >().pg->cct, "Started/Primary/Active/Clean") + NamedState(context< RecoveryMachine >().pg, "Started/Primary/Active/Clean") { context< RecoveryMachine >().log_enter(state_name); @@ -6931,7 +6992,7 @@ set unique_osd_shard_set(const pg_shard_t & skip, const T &in) /*---------Active---------*/ PG::RecoveryState::Active::Active(my_context ctx) : my_base(ctx), - NamedState(context< RecoveryMachine >().pg->cct, "Started/Primary/Active"), + NamedState(context< RecoveryMachine >().pg, "Started/Primary/Active"), remote_shards_to_reserve_recovery( unique_osd_shard_set( context< RecoveryMachine >().pg->pg_whoami, @@ -7245,7 +7306,7 @@ void PG::RecoveryState::Active::exit() /*------ReplicaActive-----*/ PG::RecoveryState::ReplicaActive::ReplicaActive(my_context ctx) : my_base(ctx), - NamedState(context< RecoveryMachine >().pg->cct, "Started/ReplicaActive") + NamedState(context< RecoveryMachine >().pg, "Started/ReplicaActive") { context< RecoveryMachine >().log_enter(state_name); @@ -7337,7 +7398,7 @@ void PG::RecoveryState::ReplicaActive::exit() /*-------Stray---*/ PG::RecoveryState::Stray::Stray(my_context ctx) : my_base(ctx), - NamedState(context< RecoveryMachine >().pg->cct, "Started/Stray") + NamedState(context< RecoveryMachine >().pg, "Started/Stray") { context< RecoveryMachine >().log_enter(state_name); @@ -7449,7 +7510,7 @@ void PG::RecoveryState::Stray::exit() /*--------GetInfo---------*/ PG::RecoveryState::GetInfo::GetInfo(my_context ctx) : my_base(ctx), - NamedState(context< RecoveryMachine >().pg->cct, "Started/Primary/Peering/GetInfo") + NamedState(context< RecoveryMachine >().pg, "Started/Primary/Peering/GetInfo") { context< RecoveryMachine >().log_enter(state_name); @@ -7651,7 +7712,7 @@ void PG::RecoveryState::GetInfo::exit() PG::RecoveryState::GetLog::GetLog(my_context ctx) : my_base(ctx), NamedState( - context< RecoveryMachine >().pg->cct, "Started/Primary/Peering/GetLog"), + context< RecoveryMachine >().pg, "Started/Primary/Peering/GetLog"), msg(0) { context< RecoveryMachine >().log_enter(state_name); @@ -7785,7 +7846,7 @@ void PG::RecoveryState::GetLog::exit() /*------WaitActingChange--------*/ PG::RecoveryState::WaitActingChange::WaitActingChange(my_context ctx) : my_base(ctx), - NamedState(context< RecoveryMachine >().pg->cct, "Started/Primary/Peering/WaitActingChange") + NamedState(context< RecoveryMachine >().pg, "Started/Primary/Peering/WaitActingChange") { context< RecoveryMachine >().log_enter(state_name); } @@ -7848,7 +7909,7 @@ void PG::RecoveryState::WaitActingChange::exit() /*------Down--------*/ PG::RecoveryState::Down::Down(my_context ctx) : my_base(ctx), - NamedState(context< RecoveryMachine >().pg->cct, "Started/Primary/Peering/Down") + NamedState(context< RecoveryMachine >().pg, "Started/Primary/Peering/Down") { context< RecoveryMachine >().log_enter(state_name); PG *pg = context< RecoveryMachine >().pg; @@ -7889,7 +7950,7 @@ boost::statechart::result PG::RecoveryState::Down::react(const QueryState& q) /*------Incomplete--------*/ PG::RecoveryState::Incomplete::Incomplete(my_context ctx) : my_base(ctx), - NamedState(context< RecoveryMachine >().pg->cct, "Started/Primary/Peering/Incomplete") + NamedState(context< RecoveryMachine >().pg, "Started/Primary/Peering/Incomplete") { context< RecoveryMachine >().log_enter(state_name); PG *pg = context< RecoveryMachine >().pg; @@ -7956,7 +8017,7 @@ void PG::RecoveryState::Incomplete::exit() /*------GetMissing--------*/ PG::RecoveryState::GetMissing::GetMissing(my_context ctx) : my_base(ctx), - NamedState(context< RecoveryMachine >().pg->cct, "Started/Primary/Peering/GetMissing") + NamedState(context< RecoveryMachine >().pg, "Started/Primary/Peering/GetMissing") { context< RecoveryMachine >().log_enter(state_name); @@ -8095,7 +8156,7 @@ void PG::RecoveryState::GetMissing::exit() /*------WaitUpThru--------*/ PG::RecoveryState::WaitUpThru::WaitUpThru(my_context ctx) : my_base(ctx), - NamedState(context< RecoveryMachine >().pg->cct, "Started/Primary/Peering/WaitUpThru") + NamedState(context< RecoveryMachine >().pg, "Started/Primary/Peering/WaitUpThru") { context< RecoveryMachine >().log_enter(state_name); } diff --git a/src/osd/PG.h b/src/osd/PG.h index ea96417d5f8..c0626788acd 100644 --- a/src/osd/PG.h +++ b/src/osd/PG.h @@ -23,6 +23,7 @@ #include #include #include +#include #include "include/memory.h" #include "include/mempool.h" @@ -45,13 +46,14 @@ #include #include #include +#include #include +#include using namespace std; // #include "include/unordered_map.h" // #include "include/unordered_set.h" - //#define DEBUG_RECOVERY_OIDS // track set of recovering oids explicitly, to find counting bugs class OSD; @@ -74,6 +76,59 @@ namespace Scrub { void intrusive_ptr_add_ref(PG *pg); void intrusive_ptr_release(PG *pg); +using state_history_entry = std::tuple; +using embedded_state = std::pair; + +struct PGStateInstance { + // Time spent in pg states + + void setepoch(const epoch_t current_epoch) { + this_epoch = current_epoch; + } + + void enter_state(const utime_t entime, const char* state) { + embedded_states.push(std::make_pair(entime, state)); + } + + void exit_state(const utime_t extime) { + embedded_state this_state = embedded_states.top(); + state_history.push_back(state_history_entry{ + this_state.first, extime, this_state.second}); + embedded_states.pop(); + } + + epoch_t this_epoch; + utime_t enter_time; + std::vector state_history; + std::stack embedded_states; +}; + +class PGStateHistory { + // Member access protected with the PG lock +public: + PGStateHistory() : buffer(10) {} + + void enter(PG* pg, const utime_t entime, const char* state); + + void exit(const char* state); + + void reset() { + pi = nullptr; + } + + void set_pg_in_destructor() { pg_in_destructor = true; } + + void dump(Formatter* f) const; + +private: + bool pg_in_destructor = false; + PG* thispg = nullptr; + std::unique_ptr tmppi; + PGStateInstance* pi = nullptr; + boost::circular_buffer> buffer; + +}; + #ifdef PG_DEBUG_REFS #include "common/tracked_int_ptr.hpp" uint64_t get_with_id(PG *pg); @@ -654,14 +709,19 @@ public: } }; + + PGStateHistory pgstate_history; + struct NamedState { const char *state_name; utime_t enter_time; + PG* pg; const char *get_state_name() { return state_name; } - NamedState(CephContext *cct_, const char *state_name_) - : state_name(state_name_), - enter_time(ceph_clock_now()) {} - virtual ~NamedState() {} + NamedState(PG *pg_, const char *state_name_) + : state_name(state_name_), enter_time(ceph_clock_now()), pg(pg_) { + pg->pgstate_history.enter(pg, enter_time, state_name); + } + virtual ~NamedState() { pg->pgstate_history.exit(state_name); } }; diff --git a/src/osd/PrimaryLogPG.cc b/src/osd/PrimaryLogPG.cc index 427571551f0..518e00b1e20 100644 --- a/src/osd/PrimaryLogPG.cc +++ b/src/osd/PrimaryLogPG.cc @@ -13270,7 +13270,7 @@ void PrimaryLogPG::SnapTrimmer::log_exit(const char *state_name, utime_t enter_t /* NotTrimming */ PrimaryLogPG::NotTrimming::NotTrimming(my_context ctx) : my_base(ctx), - NamedState(context< SnapTrimmer >().pg->cct, "NotTrimming") + NamedState(context< SnapTrimmer >().pg, "NotTrimming") { context< SnapTrimmer >().log_enter(state_name); } @@ -13324,7 +13324,7 @@ boost::statechart::result PrimaryLogPG::WaitReservation::react(const SnapTrimRes /* AwaitAsyncWork */ PrimaryLogPG::AwaitAsyncWork::AwaitAsyncWork(my_context ctx) : my_base(ctx), - NamedState(context< SnapTrimmer >().pg->cct, "Trimming/AwaitAsyncWork") + NamedState(context< SnapTrimmer >().pg, "Trimming/AwaitAsyncWork") { auto *pg = context< SnapTrimmer >().pg; context< SnapTrimmer >().log_enter(state_name); diff --git a/src/osd/PrimaryLogPG.h b/src/osd/PrimaryLogPG.h index 8f56f060edf..d6c4905db73 100644 --- a/src/osd/PrimaryLogPG.h +++ b/src/osd/PrimaryLogPG.h @@ -1482,7 +1482,7 @@ private: explicit Trimming(my_context ctx) : my_base(ctx), - NamedState(context< SnapTrimmer >().pg->cct, "Trimming") { + NamedState(context< SnapTrimmer >().pg, "Trimming") { context< SnapTrimmer >().log_enter(state_name); assert(context< SnapTrimmer >().can_trim()); assert(in_flight.empty()); @@ -1507,7 +1507,7 @@ private: Context *wakeup = nullptr; explicit WaitTrimTimer(my_context ctx) : my_base(ctx), - NamedState(context< SnapTrimmer >().pg->cct, "Trimming/WaitTrimTimer") { + NamedState(context< SnapTrimmer >().pg, "Trimming/WaitTrimTimer") { context< SnapTrimmer >().log_enter(state_name); assert(context().in_flight.empty()); struct OnTimer : Context { @@ -1557,7 +1557,7 @@ private: > reactions; explicit WaitRWLock(my_context ctx) : my_base(ctx), - NamedState(context< SnapTrimmer >().pg->cct, "Trimming/WaitRWLock") { + NamedState(context< SnapTrimmer >().pg, "Trimming/WaitRWLock") { context< SnapTrimmer >().log_enter(state_name); assert(context().in_flight.empty()); } @@ -1580,7 +1580,7 @@ private: > reactions; explicit WaitRepops(my_context ctx) : my_base(ctx), - NamedState(context< SnapTrimmer >().pg->cct, "Trimming/WaitRepops") { + NamedState(context< SnapTrimmer >().pg, "Trimming/WaitRepops") { context< SnapTrimmer >().log_enter(state_name); assert(!context().in_flight.empty()); } @@ -1634,7 +1634,7 @@ private: explicit WaitReservation(my_context ctx) : my_base(ctx), - NamedState(context< SnapTrimmer >().pg->cct, "Trimming/WaitReservation") { + NamedState(context< SnapTrimmer >().pg, "Trimming/WaitReservation") { context< SnapTrimmer >().log_enter(state_name); assert(context().in_flight.empty()); auto *pg = context< SnapTrimmer >().pg; @@ -1666,7 +1666,7 @@ private: > reactions; explicit WaitScrub(my_context ctx) : my_base(ctx), - NamedState(context< SnapTrimmer >().pg->cct, "Trimming/WaitScrub") { + NamedState(context< SnapTrimmer >().pg, "Trimming/WaitScrub") { context< SnapTrimmer >().log_enter(state_name); } void exit() {