doryan/BloomPatched
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Replaced ReportTargetControllerState event with TC command and renamed TargetControllerStateReported event

Browse Source
This commit is contained in:
Nav
2022-04-27 21:27:59 +01:00
parent f42abe1342
commit 687e28718c
12 changed files with 46 additions and 91 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
src/DebugServer/Gdb/GdbRspDebugServer.cpp
View File

@@ -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<Events::TargetControllerStateReported>(
std::bind(&GdbRspDebugServer::onTargetControllerStateReported, this, std::placeholders::_1)
this->eventListener.registerCallbackForEventType<Events::TargetControllerStateChanged>(
std::bind(&GdbRspDebugServer::onTargetControllerStateChanged, this, std::placeholders::_1)
);
this->eventListener.registerCallbackForEventType<Events::TargetExecutionStopped>(
@@ -293,12 +295,9 @@ namespace Bloom::DebugServer::Gdb
EventManager::triggerEvent(std::make_shared<Events::DebugSessionFinished>());
}
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();
}
}

4
src/DebugServer/Gdb/GdbRspDebugServer.hpp
View File

@@ -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

3
src/EventManager/Events/Event.hpp
View File

@@ -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,

3
src/EventManager/Events/Events.hpp
View File

@@ -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"

28
src/EventManager/Events/ReportTargetControllerState.hpp
View File

@@ -1,28 +0,0 @@
#pragma once
#include <string>
#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;
}
};
}

14
src/EventManager/Events/TargetControllerStateReported.hpp → src/EventManager/Events/TargetControllerStateChanged.hpp
View File

@@ -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;
}
};
}

20
src/Insight/InsightWorker/InsightWorker.cpp
View File

@@ -3,7 +3,8 @@
#include <QObject>
#include <QTimer>
#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<Events::TargetControllerStateReported>(
std::bind(&InsightWorker::onTargetControllerStateReportedEvent, this, std::placeholders::_1)
this->eventListener->registerCallbackForEventType<Events::TargetControllerStateChanged>(
std::bind(&InsightWorker::onTargetControllerStateChangedEvent, this, std::placeholders::_1)
);
this->eventListener->registerCallbackForEventType<Events::TargetExecutionStopped>(
@@ -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() {

5
src/Insight/InsightWorker/InsightWorker.hpp
View File

@@ -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();
};

1
src/TargetController/Commands/CommandTypes.hpp
View File

@@ -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,

24
src/TargetController/TargetControllerComponent.cpp
View File

@@ -92,6 +92,10 @@ namespace Bloom::TargetController
this->shutdown();
}
TargetControllerState TargetControllerComponent::getState() {
return TargetControllerComponent::state;
}
void TargetControllerComponent::registerCommand(std::unique_ptr<Command> 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<Events::ReportTargetControllerState>(
std::bind(&TargetControllerComponent::onStateReportRequest, this, std::placeholders::_1)
);
this->eventListener->registerCallbackForEventType<Events::ShutdownTargetController>(
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<TargetControllerStateReported>(this->state));
TargetControllerComponent::state = TargetControllerState::SUSPENDED;
EventManager::triggerEvent(std::make_shared<TargetControllerStateChanged>(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<TargetControllerStateReported>(this->state)
std::make_shared<TargetControllerStateChanged>(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<Events::TargetControllerStateReported>(this->state);
stateEvent->correlationId = event.id;
EventManager::triggerEvent(stateEvent);
}
void TargetControllerComponent::onExtractTargetDescriptor(const Events::ExtractTargetDescriptor& event) {
auto targetDescriptorExtracted = std::make_shared<TargetDescriptorExtracted>();
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();

14
src/TargetController/TargetControllerComponent.hpp
View File

@@ -1,5 +1,6 @@
#pragma once
#include <atomic>
#include <memory>
#include <queue>
#include <condition_variable>
@@ -43,6 +44,8 @@
namespace Bloom::TargetController
{
static_assert(std::atomic<TargetControllerState>::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<Commands::Command> command);
static std::optional<std::unique_ptr<Responses::Response>> 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<TargetControllerState> 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.
*

6
src/TargetController/TargetControllerConsole.cpp
View File

@@ -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<ReportTargetControllerState>()
)->state;
return TargetControllerComponent::getState();
}
bool TargetControllerConsole::isTargetControllerInService() noexcept {