From 687e28718cdb8d771372088e74e4c33bb04726b9 Mon Sep 17 00:00:00 2001 From: Nav Date: Wed, 27 Apr 2022 21:27:59 +0100 Subject: [PATCH] Replaced ReportTargetControllerState event with TC command and renamed TargetControllerStateReported event --- src/DebugServer/Gdb/GdbRspDebugServer.cpp | 15 +++++----- src/DebugServer/Gdb/GdbRspDebugServer.hpp | 4 +-- src/EventManager/Events/Event.hpp | 3 +- src/EventManager/Events/Events.hpp | 3 +- .../Events/ReportTargetControllerState.hpp | 28 ------------------- ...d.hpp => TargetControllerStateChanged.hpp} | 14 ++++++---- src/Insight/InsightWorker/InsightWorker.cpp | 20 +++++-------- src/Insight/InsightWorker/InsightWorker.hpp | 5 +--- .../Commands/CommandTypes.hpp | 1 + .../TargetControllerComponent.cpp | 24 ++++++---------- .../TargetControllerComponent.hpp | 14 ++++------ .../TargetControllerConsole.cpp | 6 ++-- 12 files changed, 46 insertions(+), 91 deletions(-) delete mode 100644 src/EventManager/Events/ReportTargetControllerState.hpp rename src/EventManager/Events/{TargetControllerStateReported.hpp => TargetControllerStateChanged.hpp} (59%) diff --git a/src/DebugServer/Gdb/GdbRspDebugServer.cpp b/src/DebugServer/Gdb/GdbRspDebugServer.cpp index 3ae2c070..71fc4b6c 100644 --- a/src/DebugServer/Gdb/GdbRspDebugServer.cpp +++ b/src/DebugServer/Gdb/GdbRspDebugServer.cpp @@ -37,6 +37,8 @@ namespace Bloom::DebugServer::Gdb using CommandPackets::CommandPacket; + using TargetController::TargetControllerState; + GdbRspDebugServer::GdbRspDebugServer( const DebugServerConfig& debugServerConfig, EventListener& eventListener, @@ -108,8 +110,8 @@ namespace Bloom::DebugServer::Gdb Logger::info("GDB RSP address: " + this->debugServerConfig.listeningAddress); Logger::info("GDB RSP port: " + std::to_string(this->debugServerConfig.listeningPortNumber)); - this->eventListener.registerCallbackForEventType( - std::bind(&GdbRspDebugServer::onTargetControllerStateReported, this, std::placeholders::_1) + this->eventListener.registerCallbackForEventType( + std::bind(&GdbRspDebugServer::onTargetControllerStateChanged, this, std::placeholders::_1) ); this->eventListener.registerCallbackForEventType( @@ -293,12 +295,9 @@ namespace Bloom::DebugServer::Gdb EventManager::triggerEvent(std::make_shared()); } - void GdbRspDebugServer::onTargetControllerStateReported(const Events::TargetControllerStateReported& event) { - if ( - event.state == TargetController::TargetControllerState::SUSPENDED - && this->activeDebugSession.has_value() - ) { - Logger::warning("Terminating debug session - TargetController suspended unexpectedly"); + void GdbRspDebugServer::onTargetControllerStateChanged(const Events::TargetControllerStateChanged& event) { + if (event.state == TargetControllerState::SUSPENDED && this->activeDebugSession.has_value()) { + Logger::warning("TargetController suspended unexpectedly - terminating debug session"); this->terminateActiveDebugSession(); } } diff --git a/src/DebugServer/Gdb/GdbRspDebugServer.hpp b/src/DebugServer/Gdb/GdbRspDebugServer.hpp index 70702ad8..6b7251f8 100644 --- a/src/DebugServer/Gdb/GdbRspDebugServer.hpp +++ b/src/DebugServer/Gdb/GdbRspDebugServer.hpp @@ -23,7 +23,7 @@ #include "Feature.hpp" #include "CommandPackets/CommandPacket.hpp" -#include "src/EventManager/Events/TargetControllerStateReported.hpp" +#include "src/EventManager/Events/TargetControllerStateChanged.hpp" #include "src/EventManager/Events/TargetExecutionStopped.hpp" namespace Bloom::DebugServer::Gdb @@ -186,7 +186,7 @@ namespace Bloom::DebugServer::Gdb * * @param event */ - void onTargetControllerStateReported(const Events::TargetControllerStateReported& event); + void onTargetControllerStateChanged(const Events::TargetControllerStateChanged& event); /** * If the GDB client is currently waiting for the target execution to stop, this event handler will issue diff --git a/src/EventManager/Events/Event.hpp b/src/EventManager/Events/Event.hpp index 73a2321b..1fe1e20b 100644 --- a/src/EventManager/Events/Event.hpp +++ b/src/EventManager/Events/Event.hpp @@ -19,8 +19,7 @@ namespace Bloom::Events DEBUG_SESSION_STARTED, DEBUG_SESSION_FINISHED, TARGET_CONTROLLER_THREAD_STATE_CHANGED, - REPORT_TARGET_CONTROLLER_STATE, - TARGET_CONTROLLER_STATE_REPORTED, + TARGET_CONTROLLER_STATE_CHANGED, SHUTDOWN_TARGET_CONTROLLER, TARGET_CONTROLLER_ERROR_OCCURRED, SHUTDOWN_APPLICATION, diff --git a/src/EventManager/Events/Events.hpp b/src/EventManager/Events/Events.hpp index cbe359f0..e6467eb5 100644 --- a/src/EventManager/Events/Events.hpp +++ b/src/EventManager/Events/Events.hpp @@ -6,8 +6,7 @@ #include "DebugSessionStarted.hpp" #include "DebugSessionFinished.hpp" #include "TargetControllerThreadStateChanged.hpp" -#include "ReportTargetControllerState.hpp" -#include "TargetControllerStateReported.hpp" +#include "TargetControllerStateChanged.hpp" #include "ShutdownTargetController.hpp" #include "TargetControllerErrorOccurred.hpp" #include "ShutdownApplication.hpp" diff --git a/src/EventManager/Events/ReportTargetControllerState.hpp b/src/EventManager/Events/ReportTargetControllerState.hpp deleted file mode 100644 index 3818a778..00000000 --- a/src/EventManager/Events/ReportTargetControllerState.hpp +++ /dev/null @@ -1,28 +0,0 @@ -#pragma once - -#include - -#include "Event.hpp" -#include "TargetControllerStateReported.hpp" - -namespace Bloom::Events -{ - class ReportTargetControllerState: public Event - { - public: - using TargetControllerResponseType = TargetControllerStateReported; - - static constexpr EventType type = EventType::REPORT_TARGET_CONTROLLER_STATE; - static inline const std::string name = "ReportTargetControllerState"; - - ReportTargetControllerState() {}; - - [[nodiscard]] EventType getType() const override { - return ReportTargetControllerState::type; - } - - [[nodiscard]] std::string getName() const override { - return ReportTargetControllerState::name; - } - }; -} diff --git a/src/EventManager/Events/TargetControllerStateReported.hpp b/src/EventManager/Events/TargetControllerStateChanged.hpp similarity index 59% rename from src/EventManager/Events/TargetControllerStateReported.hpp rename to src/EventManager/Events/TargetControllerStateChanged.hpp index c1800e34..41bafe04 100644 --- a/src/EventManager/Events/TargetControllerStateReported.hpp +++ b/src/EventManager/Events/TargetControllerStateChanged.hpp @@ -7,21 +7,23 @@ namespace Bloom::Events { - class TargetControllerStateReported: public Event + class TargetControllerStateChanged: public Event { public: - static constexpr EventType type = EventType::TARGET_CONTROLLER_STATE_REPORTED; - static inline const std::string name = "TargetControllerStateReported"; + static constexpr EventType type = EventType::TARGET_CONTROLLER_STATE_CHANGED; + static inline const std::string name = "TargetControllerStateChanged"; TargetController::TargetControllerState state; - explicit TargetControllerStateReported(TargetController::TargetControllerState state): state(state) {}; + explicit TargetControllerStateChanged(TargetController::TargetControllerState state) + : state(state) + {}; [[nodiscard]] EventType getType() const override { - return TargetControllerStateReported::type; + return TargetControllerStateChanged::type; } [[nodiscard]] std::string getName() const override { - return TargetControllerStateReported::name; + return TargetControllerStateChanged::name; } }; } diff --git a/src/Insight/InsightWorker/InsightWorker.cpp b/src/Insight/InsightWorker/InsightWorker.cpp index 27b84162..c862f6c2 100644 --- a/src/Insight/InsightWorker/InsightWorker.cpp +++ b/src/Insight/InsightWorker/InsightWorker.cpp @@ -3,7 +3,8 @@ #include #include -#include "src/Helpers/Thread.hpp" +#include "src/TargetController/TargetControllerState.hpp" + #include "src/Logger/Logger.hpp" namespace Bloom @@ -24,8 +25,8 @@ namespace Bloom Logger::debug("Starting InsightWorker thread"); EventManager::registerListener(this->eventListener); - this->eventListener->registerCallbackForEventType( - std::bind(&InsightWorker::onTargetControllerStateReportedEvent, this, std::placeholders::_1) + this->eventListener->registerCallbackForEventType( + std::bind(&InsightWorker::onTargetControllerStateChangedEvent, this, std::placeholders::_1) ); this->eventListener->registerCallbackForEventType( @@ -125,19 +126,13 @@ namespace Bloom emit this->targetRegistersWritten(event.registers, event.createdTimestamp); } - void InsightWorker::onTargetControllerStateReportedEvent(const Events::TargetControllerStateReported& event) { + void InsightWorker::onTargetControllerStateChangedEvent(const Events::TargetControllerStateChanged& event) { using TargetController::TargetControllerState; - if ( - this->lastTargetControllerState == TargetControllerState::ACTIVE - && event.state == TargetControllerState::SUSPENDED - ) { + if (event.state == TargetControllerState::SUSPENDED) { emit this->targetControllerSuspended(); - } else if ( - this->lastTargetControllerState == TargetControllerState::SUSPENDED - && event.state == TargetControllerState::ACTIVE - ) { + } else if (event.state == TargetControllerState::ACTIVE) { try { emit this->targetControllerResumed(this->targetControllerConsole.getTargetDescriptor()); @@ -145,7 +140,6 @@ namespace Bloom Logger::error("Insight resume failed - " + exception.getMessage()); } } - this->lastTargetControllerState = event.state; } void InsightWorker::executeTasks() { diff --git a/src/Insight/InsightWorker/InsightWorker.hpp b/src/Insight/InsightWorker/InsightWorker.hpp index 61b4e81e..2d0f99ce 100644 --- a/src/Insight/InsightWorker/InsightWorker.hpp +++ b/src/Insight/InsightWorker/InsightWorker.hpp @@ -12,7 +12,6 @@ #include "src/EventManager/Events/Events.hpp" #include "src/TargetController/TargetControllerConsole.hpp" -#include "src/TargetController/TargetControllerState.hpp" #include "Tasks/InsightWorkerTask.hpp" @@ -52,8 +51,6 @@ namespace Bloom TargetController::TargetControllerConsole targetControllerConsole = TargetController::TargetControllerConsole( *(this->eventListener) ); - TargetController::TargetControllerState lastTargetControllerState = - TargetController::TargetControllerState::ACTIVE; Targets::TargetState lastTargetState = Targets::TargetState::UNKNOWN; @@ -67,7 +64,7 @@ namespace Bloom void onTargetResumedEvent(const Events::TargetExecutionResumed& event); void onTargetResetEvent(const Events::TargetReset& event); void onTargetRegistersWrittenEvent(const Events::RegistersWrittenToTarget& event); - void onTargetControllerStateReportedEvent(const Events::TargetControllerStateReported& event); + void onTargetControllerStateChangedEvent(const Events::TargetControllerStateChanged& event); void executeTasks(); }; diff --git a/src/TargetController/Commands/CommandTypes.hpp b/src/TargetController/Commands/CommandTypes.hpp index 33f78769..04487c68 100644 --- a/src/TargetController/Commands/CommandTypes.hpp +++ b/src/TargetController/Commands/CommandTypes.hpp @@ -7,6 +7,7 @@ namespace Bloom::TargetController::Commands enum class CommandType: std::uint8_t { GENERIC, + GET_TARGET_CONTROLLER_STATE, STOP_TARGET_EXECUTION, RESUME_TARGET_EXECUTION, RESET_TARGET, diff --git a/src/TargetController/TargetControllerComponent.cpp b/src/TargetController/TargetControllerComponent.cpp index aced880b..511c1879 100644 --- a/src/TargetController/TargetControllerComponent.cpp +++ b/src/TargetController/TargetControllerComponent.cpp @@ -92,6 +92,10 @@ namespace Bloom::TargetController this->shutdown(); } + TargetControllerState TargetControllerComponent::getState() { + return TargetControllerComponent::state; + } + void TargetControllerComponent::registerCommand(std::unique_ptr command) { auto commandQueueLock = TargetControllerComponent::commandQueue.acquireLock(); TargetControllerComponent::commandQueue.getValue().push(std::move(command)); @@ -149,10 +153,6 @@ namespace Bloom::TargetController TargetControllerComponent::checkUdevRules(); // Register event handlers - this->eventListener->registerCallbackForEventType( - std::bind(&TargetControllerComponent::onStateReportRequest, this, std::placeholders::_1) - ); - this->eventListener->registerCallbackForEventType( std::bind(&TargetControllerComponent::onShutdownTargetControllerEvent, this, std::placeholders::_1) ); @@ -400,8 +400,8 @@ namespace Bloom::TargetController this->registerDescriptorsByMemoryType.clear(); this->registerAddressRangeByMemoryType.clear(); - this->state = TargetControllerState::SUSPENDED; - EventManager::triggerEvent(std::make_shared(this->state)); + TargetControllerComponent::state = TargetControllerState::SUSPENDED; + EventManager::triggerEvent(std::make_shared(TargetControllerComponent::state)); Logger::debug("TargetController suspended"); } @@ -478,9 +478,9 @@ namespace Bloom::TargetController std::bind(&TargetControllerComponent::onRetrieveStackPointerEvent, this, std::placeholders::_1) ); - this->state = TargetControllerState::ACTIVE; + TargetControllerComponent::state = TargetControllerState::ACTIVE; EventManager::triggerEvent( - std::make_shared(this->state) + std::make_shared(TargetControllerComponent::state) ); if (this->target->getState() != TargetState::RUNNING) { @@ -692,12 +692,6 @@ namespace Bloom::TargetController this->shutdown(); } - void TargetControllerComponent::onStateReportRequest(const Events::ReportTargetControllerState& event) { - auto stateEvent = std::make_shared(this->state); - stateEvent->correlationId = event.id; - EventManager::triggerEvent(stateEvent); - } - void TargetControllerComponent::onExtractTargetDescriptor(const Events::ExtractTargetDescriptor& event) { auto targetDescriptorExtracted = std::make_shared(); targetDescriptorExtracted->targetDescriptor = this->getTargetDescriptor(); @@ -707,7 +701,7 @@ namespace Bloom::TargetController } void TargetControllerComponent::onDebugSessionStartedEvent(const Events::DebugSessionStarted&) { - if (this->state == TargetControllerState::SUSPENDED) { + if (TargetControllerComponent::state == TargetControllerState::SUSPENDED) { Logger::debug("Waking TargetController"); this->resume(); diff --git a/src/TargetController/TargetControllerComponent.hpp b/src/TargetController/TargetControllerComponent.hpp index 413d5835..2836c253 100644 --- a/src/TargetController/TargetControllerComponent.hpp +++ b/src/TargetController/TargetControllerComponent.hpp @@ -1,5 +1,6 @@ #pragma once +#include #include #include #include @@ -43,6 +44,8 @@ namespace Bloom::TargetController { + static_assert(std::atomic::is_always_lock_free); + /** * The TargetController possesses full control of the debugging target and the debug tool. * @@ -65,6 +68,8 @@ namespace Bloom::TargetController */ void run(); + static TargetControllerState getState(); + static void registerCommand(std::unique_ptr command); static std::optional> waitForResponse( @@ -88,7 +93,7 @@ namespace Bloom::TargetController * The TC starts off in a suspended state. TargetControllerComponent::resume() is invoked from the startup * routine. */ - TargetControllerState state = TargetControllerState::SUSPENDED; + static inline std::atomic state = TargetControllerState::SUSPENDED; ProjectConfig projectConfig; EnvironmentConfig environmentConfig; @@ -265,13 +270,6 @@ namespace Bloom::TargetController */ void onShutdownTargetControllerEvent(const Events::ShutdownTargetController& event); - /** - * Reports the current state of the TargetController. - * - * @param event - */ - void onStateReportRequest(const Events::ReportTargetControllerState& event); - /** * Obtains a TargetDescriptor from the target and includes it in a TargetDescriptorExtracted event. * diff --git a/src/TargetController/TargetControllerConsole.cpp b/src/TargetController/TargetControllerConsole.cpp index 1939dfa8..facab62d 100644 --- a/src/TargetController/TargetControllerConsole.cpp +++ b/src/TargetController/TargetControllerConsole.cpp @@ -2,6 +2,8 @@ #include "src/EventManager/Events/Events.hpp" +#include "TargetControllerComponent.hpp" + // Commands #include "Commands/StopTargetExecution.hpp" #include "Commands/ResumeTargetExecution.hpp" @@ -30,9 +32,7 @@ namespace Bloom::TargetController {} TargetControllerState TargetControllerConsole::getTargetControllerState() { - return this->triggerTargetControllerEventAndWaitForResponse( - std::make_shared() - )->state; + return TargetControllerComponent::getState(); } bool TargetControllerConsole::isTargetControllerInService() noexcept {