From a7df862d36e3477e0c28dabb7a7d8b6f4b03aaa9 Mon Sep 17 00:00:00 2001 From: Nav Date: Tue, 22 Jun 2021 03:06:20 +0100 Subject: [PATCH] Moved away from shared pointers in event handlers - didn't make sense to expose the event management implementation to handlers. Also some other bits of tidying. --- src/Application.cpp | 10 +- src/Application.hpp | 6 +- src/DebugServers/DebugServer.cpp | 2 +- src/DebugServers/DebugServer.hpp | 2 +- src/DebugServers/GdbRsp/GdbRspDebugServer.cpp | 9 +- src/DebugServers/GdbRsp/GdbRspDebugServer.hpp | 6 +- .../Microchip/AtmelICE/AtmelIce.cpp | 2 +- src/EventManager/EventListener.cpp | 35 ++--- src/EventManager/EventListener.hpp | 64 ++++----- src/EventManager/EventManager.hpp | 2 +- src/EventManager/Events/Event.hpp | 10 +- src/EventManager/Events/Events.hpp | 8 +- src/Insight/Insight.cpp | 6 +- src/Insight/Insight.hpp | 4 +- src/Insight/InsightWorker.cpp | 20 +-- src/Insight/InsightWorker.hpp | 11 +- src/TargetController/TargetController.cpp | 132 +++++++++--------- src/TargetController/TargetController.hpp | 40 +++--- .../TargetControllerConsole.cpp | 36 ++--- 19 files changed, 193 insertions(+), 212 deletions(-) diff --git a/src/Application.cpp b/src/Application.cpp index 82653344..2db0ae05 100644 --- a/src/Application.cpp +++ b/src/Application.cpp @@ -323,20 +323,20 @@ void Application::stopDebugServer() { } } -void Application::onTargetControllerThreadStateChanged(EventPointer event) { - if (event->getState() == ThreadState::STOPPED || event->getState() == ThreadState::SHUTDOWN_INITIATED) { +void Application::onTargetControllerThreadStateChanged(EventRef event) { + if (event.getState() == ThreadState::STOPPED || event.getState() == ThreadState::SHUTDOWN_INITIATED) { // TargetController has unexpectedly shutdown - it must have encountered a fatal error. this->shutdown(); } } -void Application::onShutdownApplicationRequest(EventPointer) { +void Application::onShutdownApplicationRequest(EventRef) { Logger::debug("ShutdownApplication event received."); this->shutdown(); } -void Application::onDebugServerThreadStateChanged(EventPointer event) { - if (event->getState() == ThreadState::STOPPED || event->getState() == ThreadState::SHUTDOWN_INITIATED) { +void Application::onDebugServerThreadStateChanged(EventRef event) { + if (event.getState() == ThreadState::STOPPED || event.getState() == ThreadState::SHUTDOWN_INITIATED) { // DebugServer has unexpectedly shutdown - it must have encountered a fatal error. this->shutdown(); } diff --git a/src/Application.hpp b/src/Application.hpp index a0da893a..1d4f821b 100644 --- a/src/Application.hpp +++ b/src/Application.hpp @@ -233,7 +233,7 @@ namespace Bloom * * @param event */ - void onTargetControllerThreadStateChanged(Events::EventPointer event); + void onTargetControllerThreadStateChanged(Events::EventRef event); /** * Same goes for the DebugServer - it should never shutdown unless a shutdown request was issued. If it does, @@ -241,12 +241,12 @@ namespace Bloom * * @param event */ - void onDebugServerThreadStateChanged(Events::EventPointer event); + void onDebugServerThreadStateChanged(Events::EventRef event); /** * Triggers a shutdown of Bloom and all of its components. */ - void onShutdownApplicationRequest(Events::EventPointer); + void onShutdownApplicationRequest(Events::EventRef); /** * Checks if the current effective user running Bloom has root privileges. diff --git a/src/DebugServers/DebugServer.cpp b/src/DebugServers/DebugServer.cpp index 83a72948..a33467c3 100644 --- a/src/DebugServers/DebugServer.cpp +++ b/src/DebugServers/DebugServer.cpp @@ -55,6 +55,6 @@ void DebugServer::shutdown() { this->eventManager.deregisterListener(this->eventListener->getId()); } -void DebugServer::onShutdownDebugServerEvent(EventPointer event) { +void DebugServer::onShutdownDebugServerEvent(EventRef event) { this->shutdown(); } diff --git a/src/DebugServers/DebugServer.hpp b/src/DebugServers/DebugServer.hpp index 4b78fd5a..46d700d5 100644 --- a/src/DebugServers/DebugServer.hpp +++ b/src/DebugServers/DebugServer.hpp @@ -59,7 +59,7 @@ namespace Bloom::DebugServers * * @param event */ - void onShutdownDebugServerEvent(Events::EventPointer event); + void onShutdownDebugServerEvent(Events::EventRef event); protected: /** diff --git a/src/DebugServers/GdbRsp/GdbRspDebugServer.cpp b/src/DebugServers/GdbRsp/GdbRspDebugServer.cpp index 18d3a5f5..044f3ed0 100644 --- a/src/DebugServers/GdbRsp/GdbRspDebugServer.cpp +++ b/src/DebugServers/GdbRsp/GdbRspDebugServer.cpp @@ -201,8 +201,8 @@ void GdbRspDebugServer::waitForConnection() { } } -void GdbRspDebugServer::onTargetControllerStateReported(Events::EventPointer event) { - if (event->state == TargetControllerState::SUSPENDED && this->clientConnection.has_value()) { +void GdbRspDebugServer::onTargetControllerStateReported(Events::EventRef event) { + if (event.state == TargetControllerState::SUSPENDED && this->clientConnection.has_value()) { Logger::warning("Terminating debug session - TargetController suspended unexpectedly"); this->closeClientConnection(); } @@ -232,7 +232,7 @@ void GdbRspDebugServer::handleGdbPacket(CommandPacket& packet) { } } -void GdbRspDebugServer::onTargetExecutionStopped(EventPointer) { +void GdbRspDebugServer::onTargetExecutionStopped(EventRef) { if (this->clientConnection.has_value() && this->clientConnection->waitingForBreak) { this->clientConnection->writePacket(TargetStopped(Signal::TRAP)); this->clientConnection->waitingForBreak = false; @@ -243,7 +243,8 @@ void GdbRspDebugServer::handleGdbPacket(CommandPackets::SupportedFeaturesQuery& Logger::debug("Handling QuerySupport packet"); if (!packet.isFeatureSupported(Feature::HARDWARE_BREAKPOINTS) - && !packet.isFeatureSupported(Feature::SOFTWARE_BREAKPOINTS)) { + && !packet.isFeatureSupported(Feature::SOFTWARE_BREAKPOINTS) + ) { // All GDB clients are expected to support breakpoints! throw ClientNotSupported("GDB client does not support HW or SW breakpoints"); } diff --git a/src/DebugServers/GdbRsp/GdbRspDebugServer.hpp b/src/DebugServers/GdbRsp/GdbRspDebugServer.hpp index 5b080d06..b193c593 100644 --- a/src/DebugServers/GdbRsp/GdbRspDebugServer.hpp +++ b/src/DebugServers/GdbRsp/GdbRspDebugServer.hpp @@ -163,19 +163,19 @@ namespace Bloom::DebugServers::Gdb } public: - GdbRspDebugServer(EventManager& eventManager): DebugServer(eventManager) {}; + explicit GdbRspDebugServer(EventManager& eventManager): DebugServer(eventManager) {}; std::string getName() const override { return "GDB Remote Serial Protocol DebugServer"; }; - void onTargetControllerStateReported(Events::EventPointer event); + void onTargetControllerStateReported(Events::EventRef event); /** * If the GDB client is currently waiting for the target execution to stop, this event handler will issue * a "stop reply" packet to the client once the target execution stops. */ - void onTargetExecutionStopped(Events::EventPointer); + void onTargetExecutionStopped(Events::EventRef); /** * Handles any other GDB command packet that has not been promoted to a more specific type. diff --git a/src/DebugToolDrivers/Microchip/AtmelICE/AtmelIce.cpp b/src/DebugToolDrivers/Microchip/AtmelICE/AtmelIce.cpp index f7b1c2d7..5a3414ce 100644 --- a/src/DebugToolDrivers/Microchip/AtmelICE/AtmelIce.cpp +++ b/src/DebugToolDrivers/Microchip/AtmelICE/AtmelIce.cpp @@ -18,7 +18,7 @@ void AtmelIce::init() { if (!usbHidInterface.isInitialised()) { usbHidInterface.detachKernelDriver(); - UsbDevice::setConfiguration(0); + this->setConfiguration(0); usbHidInterface.init(); } diff --git a/src/EventManager/EventListener.cpp b/src/EventManager/EventListener.cpp index 1bdf2eff..85e7bb59 100644 --- a/src/EventManager/EventListener.cpp +++ b/src/EventManager/EventListener.cpp @@ -12,23 +12,14 @@ void EventListener::clearAllCallbacks() { this->eventTypeToCallbacksMapping.getReference().clear(); } -void EventListener::registerEvent(GenericEventPointer event) { - auto eventName = event->getName(); - Logger::debug("Event \"" + eventName + "\" (" + std::to_string(event->id) +void EventListener::registerEvent(SharedGenericEventPointer event) { + auto eventType = event->getName(); + Logger::debug("Event \"" + eventType + "\" (" + std::to_string(event->id) + ") registered for listener " + this->name); auto queueLock = this->eventQueueByEventType.acquireLock(); auto& eventQueueByType = this->eventQueueByEventType.getReference(); - if (!eventQueueByType.contains(eventName)) { - eventQueueByType.insert( - std::pair>( - eventName, - std::queue() - ) - ); - } - - eventQueueByType[eventName].push(event); + eventQueueByType[eventType].push(std::move(event)); this->eventQueueByEventTypeCV.notify_all(); if (this->interruptEventNotifier != nullptr && this->interruptEventNotifier->isInitialised()) { @@ -36,26 +27,26 @@ void EventListener::registerEvent(GenericEventPointer event) { } } -std::vector EventListener::getEvents() { +std::vector EventListener::getEvents() { auto queueLock = this->eventQueueByEventType.acquireLock(); auto& eventQueueByType = this->eventQueueByEventType.getReference(); - std::vector output; + std::vector output; for (auto& eventQueue: eventQueueByType) { - if (eventQueue.second.size() > 0) { - output.push_back(eventQueue.second.front()); + if (!eventQueue.second.empty()) { + output.push_back(std::move(eventQueue.second.front())); eventQueue.second.pop(); } } - std::sort(output.begin(), output.end(), [](GenericEventPointer a, GenericEventPointer b) { + std::sort(output.begin(), output.end(), [](const SharedGenericEventPointer& a, const SharedGenericEventPointer& b) { return a->id < b->id; }); return output; } -void EventListener::dispatchEvent(GenericEventPointer event) { +void EventListener::dispatchEvent(const SharedGenericEventPointer& event) { auto eventName = event->getName(); Logger::debug("Dispatching event " + eventName + " (" + std::to_string(event->id) + ")."); // Dispatch the event to all registered handlers @@ -64,7 +55,7 @@ void EventListener::dispatchEvent(GenericEventPointer event) { mappingLock.unlock(); for (auto& callback : callbacks) { - callback(event); + callback(*(event.get())); } } @@ -80,12 +71,12 @@ void EventListener::waitAndDispatch(int msTimeout) { auto queueLock = this->eventQueueByEventType.acquireLock(); auto& eventQueueByType = this->eventQueueByEventType.getReference(); auto registeredEventTypes = this->getRegisteredEventTypeNames(); - std::optional event; + std::optional event; auto eventsFound = [®isteredEventTypes, &event, &eventQueueByType]() -> bool { for (auto& eventQueue: eventQueueByType) { if (registeredEventTypes.find(eventQueue.first) != registeredEventTypes.end() - && eventQueue.second.size() > 0 + && !eventQueue.second.empty() ) { return true; } diff --git a/src/EventManager/EventListener.hpp b/src/EventManager/EventListener.hpp index d4aada6b..436b06bd 100644 --- a/src/EventManager/EventListener.hpp +++ b/src/EventManager/EventListener.hpp @@ -5,6 +5,7 @@ #include #include #include +#include #include #include #include @@ -50,7 +51,7 @@ namespace Bloom std::string name; static inline std::atomic lastId = 0; - std::size_t id = ++(this->lastId); + std::size_t id = ++(EventListener::lastId); /** * Holds all events registered to this listener. @@ -58,26 +59,26 @@ namespace Bloom * Events are grouped by event type name, and removed from their queue just *before* the dispatching to * registered handlers begins. */ - SyncSafe>> eventQueueByEventType; + SyncSafe>> eventQueueByEventType; std::condition_variable eventQueueByEventTypeCV; /** * A mapping of event type names to a vector of callback functions. Events will be dispatched to these * callback functions, during a call to EventListener::dispatchEvent(). * - * Each callback will be passed an std::shared_ptr of the event (we wrap all registered - * callbacks in a lambda, where we perform a downcast before invoking the callback. - * See EventListener::registerCallbackForEventType() for more) + * Each callback will be passed a reference to the event (we wrap all registered callbacks in a lambda, where + * we perform a downcast before invoking the callback. See EventListener::registerCallbackForEventType() + * for more) */ - SyncSafe>>> eventTypeToCallbacksMapping; + SyncSafe>>> eventTypeToCallbacksMapping; SyncSafe> registeredEventTypes; std::shared_ptr interruptEventNotifier = nullptr; - std::vector getEvents(); + std::vector getEvents(); public: - explicit EventListener(const std::string& name): name(name) {}; + explicit EventListener(std::string name): name(std::move(name)) {}; std::size_t getId() const { return this->id; @@ -95,10 +96,10 @@ namespace Bloom * * @param event */ - void registerEvent(Events::GenericEventPointer event); + void registerEvent(Events::SharedGenericEventPointer event); void setInterruptEventNotifier(std::shared_ptr interruptEventNotifier) { - this->interruptEventNotifier = interruptEventNotifier; + this->interruptEventNotifier = std::move(interruptEventNotifier); } /** @@ -109,33 +110,18 @@ namespace Bloom * @param callback */ template - void registerCallbackForEventType(std::function)> callback) { + void registerCallbackForEventType(std::function)> callback) { // We encapsulate the callback in a lambda to handle the downcasting. - std::function parentCallback = - [callback] (Events::GenericEventPointer event) { + std::function parentCallback = + [callback] (Events::GenericEventRef event) { // Downcast the event to the expected type - callback(std::dynamic_pointer_cast(event)); + callback(dynamic_cast>(event)); } ; auto mappingLock = this->eventTypeToCallbacksMapping.acquireLock(); auto& mapping = this->eventTypeToCallbacksMapping.getReference(); - if (mapping.find(EventType::name) == mapping.end()) { - /* - * Multiple callbacks can be registered for a single event type. - * - * We have no callbacks for this event type registered in this listener, so setup - * the type name to callback vector mapping. - */ - mapping.insert( - std::pair>>( - EventType::name, - std::vector>() - ) - ); - } - mapping[EventType::name].push_back(parentCallback); auto registeredEventTypesLock = this->registeredEventTypes.acquireLock(); this->registeredEventTypes.getReference().insert(EventType::name); @@ -201,20 +187,20 @@ namespace Bloom std::optional correlationId = std::nullopt ) { // Different return types, depending on how many event type arguments are passed in. - using MonoType = std::optional>; + using MonoType = std::optional>; using BiVariantType = std::optional< std::variant< std::monostate, - Events::EventPointer, - Events::EventPointer + Events::SharedEventPointer, + Events::SharedEventPointer > >; using TriVariantType = std::optional< std::variant< std::monostate, - Events::EventPointer, - Events::EventPointer, - Events::EventPointer + Events::SharedEventPointer, + Events::SharedEventPointer, + Events::SharedEventPointer > >; using ReturnType = typename std::conditional< @@ -262,14 +248,14 @@ namespace Bloom } } - Events::GenericEventPointer foundEvent = nullptr; + Events::SharedGenericEventPointer foundEvent = nullptr; auto eventsFound = [&eventTypeNames, &eventQueueByType, &correlationId, &foundEvent]() -> bool { for (const auto& eventTypeName : eventTypeNames) { if (eventQueueByType.find(eventTypeName) != eventQueueByType.end() - && eventQueueByType.find(eventTypeName)->second.size() > 0 + && !eventQueueByType.find(eventTypeName)->second.empty() ) { auto& queue = eventQueueByType.find(eventTypeName)->second; - while (queue.size() > 0) { + while (!queue.empty()) { auto event = queue.front(); if (!correlationId.has_value() @@ -347,7 +333,7 @@ namespace Bloom */ void waitAndDispatch(int msTimeout = 0); - void dispatchEvent(Events::GenericEventPointer event); + void dispatchEvent(const Events::SharedGenericEventPointer& event); void dispatchCurrentEvents(); diff --git a/src/EventManager/EventManager.hpp b/src/EventManager/EventManager.hpp index 2999619c..10fd2c69 100644 --- a/src/EventManager/EventManager.hpp +++ b/src/EventManager/EventManager.hpp @@ -53,7 +53,7 @@ namespace Bloom * * @param event */ - void triggerEvent(Events::GenericEventPointer event); + void triggerEvent(Events::SharedGenericEventPointer event); }; } diff --git a/src/EventManager/Events/Event.hpp b/src/EventManager/Events/Event.hpp index 062eec2f..a01019c6 100644 --- a/src/EventManager/Events/Event.hpp +++ b/src/EventManager/Events/Event.hpp @@ -14,21 +14,17 @@ namespace Bloom::Events class Event { private: - QDateTime createdTimestamp = DateTime::currentDateTime(); static inline std::atomic lastEventId = 0; public: - int id = ++(this->lastEventId); + int id = ++(Event::lastEventId); + QDateTime createdTimestamp = DateTime::currentDateTime(); std::optional correlationId; static inline const std::string name = "GenericEvent"; - virtual std::string getName() const { + [[nodiscard]] virtual std::string getName() const { return Event::name; } - - long getCreatedEpochTimestamp() const { - return this->createdTimestamp.toMSecsSinceEpoch(); - } }; } diff --git a/src/EventManager/Events/Events.hpp b/src/EventManager/Events/Events.hpp index e0d982c9..4cef38f9 100644 --- a/src/EventManager/Events/Events.hpp +++ b/src/EventManager/Events/Events.hpp @@ -44,7 +44,11 @@ namespace Bloom::Events { template - using EventPointer = std::shared_ptr; + using SharedEventPointer = std::shared_ptr; - using GenericEventPointer = EventPointer; + template + using EventRef = const EventType&; + + using SharedGenericEventPointer = SharedEventPointer; + using GenericEventRef = EventRef; } diff --git a/src/Insight/Insight.cpp b/src/Insight/Insight.cpp index 8b0c8652..29905381 100644 --- a/src/Insight/Insight.cpp +++ b/src/Insight/Insight.cpp @@ -119,7 +119,7 @@ void Insight::shutdown() { this->setThreadState(ThreadState::STOPPED); } -void Insight::onShutdownApplicationEvent(EventPointer) { +void Insight::onShutdownApplicationEvent(EventRef) { /* * Once Insight shuts down, control of the main thread will be returned to Application::run(), which * will pickup the ShutdownApplication event and proceed with the shutdown. @@ -127,8 +127,8 @@ void Insight::onShutdownApplicationEvent(EventPointer) { this->shutdown(); } -void Insight::onTargetControllerThreadStateChangedEvent(EventPointer event) { - if (event->getState() == ThreadState::STOPPED) { +void Insight::onTargetControllerThreadStateChangedEvent(EventRef event) { + if (event.getState() == ThreadState::STOPPED) { // Something horrible has happened with the TargetController - Insight is useless without the TargetController this->shutdown(); } diff --git a/src/Insight/Insight.hpp b/src/Insight/Insight.hpp index 4989b203..efa25726 100644 --- a/src/Insight/Insight.hpp +++ b/src/Insight/Insight.hpp @@ -81,7 +81,7 @@ namespace Bloom * * @param event */ - void onShutdownApplicationEvent(Events::EventPointer event); + void onShutdownApplicationEvent(Events::EventRef event); /** * If the something horrible was to happen and the TC dies unexpectedly, Insight will shutdown in response. @@ -89,7 +89,7 @@ namespace Bloom * @param event */ void onTargetControllerThreadStateChangedEvent( - Events::EventPointer event + Events::EventRef event ); /** diff --git a/src/Insight/InsightWorker.cpp b/src/Insight/InsightWorker.cpp index 302c4d07..c9c65d8d 100644 --- a/src/Insight/InsightWorker.cpp +++ b/src/Insight/InsightWorker.cpp @@ -60,7 +60,7 @@ void InsightWorker::requestPinStateUpdate( this->targetControllerConsole.setPinState(variantId, pinDescriptor, pinState); } -void InsightWorker::onTargetStoppedEvent(EventPointer event) { +void InsightWorker::onTargetStoppedEvent(EventRef event) { /* * When we report a target halt to Insight, Insight will immediately seek more data from the target (such as GPIO * pin states). This can be problematic for cases where the target had halted due to a conditional breakpoint. @@ -88,30 +88,30 @@ void InsightWorker::onTargetStoppedEvent(EventPointer ev if (!resumedEvent.has_value()) { emit this->targetStateUpdated(TargetState::STOPPED); - emit this->targetProgramCounterUpdated(event->programCounter); + emit this->targetProgramCounterUpdated(event.programCounter); } } -void InsightWorker::onTargetResumedEvent(EventPointer event) { +void InsightWorker::onTargetResumedEvent(EventRef event) { emit this->targetStateUpdated(TargetState::RUNNING); } -void InsightWorker::onTargetPinStatesRetrievedEvent(EventPointer event) { - emit this->targetPinStatesUpdated(event->variantId, event->pinSatesByNumber); +void InsightWorker::onTargetPinStatesRetrievedEvent(EventRef event) { + emit this->targetPinStatesUpdated(event.variantId, event.pinSatesByNumber); } -void InsightWorker::onTargetIoPortsUpdatedEvent(EventPointer event) { +void InsightWorker::onTargetIoPortsUpdatedEvent(EventRef event) { emit this->targetIoPortsUpdated(); } -void InsightWorker::onTargetControllerStateReported(EventPointer event) { +void InsightWorker::onTargetControllerStateReported(EventRef event) { if (this->lastTargetControllerState == TargetControllerState::ACTIVE - && event->state == TargetControllerState::SUSPENDED + && event.state == TargetControllerState::SUSPENDED ) { emit this->targetControllerSuspended(); } else if (this->lastTargetControllerState == TargetControllerState::SUSPENDED - && event->state == TargetControllerState::ACTIVE + && event.state == TargetControllerState::ACTIVE ) { try { emit this->targetControllerResumed(this->targetControllerConsole.getTargetDescriptor()); @@ -120,5 +120,5 @@ void InsightWorker::onTargetControllerStateReported(EventPointerlastTargetControllerState = event->state; + this->lastTargetControllerState = event.state; } diff --git a/src/Insight/InsightWorker.hpp b/src/Insight/InsightWorker.hpp index 687f9260..a8408c84 100644 --- a/src/Insight/InsightWorker.hpp +++ b/src/Insight/InsightWorker.hpp @@ -33,11 +33,11 @@ namespace Bloom QTimer* eventDispatchTimer = nullptr; - void onTargetStoppedEvent(Events::EventPointer event); - void onTargetResumedEvent(Events::EventPointer event); - void onTargetPinStatesRetrievedEvent(Events::EventPointer event); - void onTargetIoPortsUpdatedEvent(Events::EventPointer event); - void onTargetControllerStateReported(Events::EventPointer event); + void onTargetStoppedEvent(Events::EventRef event); + void onTargetResumedEvent(Events::EventRef event); + void onTargetPinStatesRetrievedEvent(Events::EventRef event); + void onTargetIoPortsUpdatedEvent(Events::EventRef event); + void onTargetControllerStateReported(Events::EventRef event); public: explicit InsightWorker(EventManager& eventManager): eventManager(eventManager) {}; @@ -62,6 +62,5 @@ namespace Bloom void targetIoPortsUpdated(); void targetControllerSuspended(); void targetControllerResumed(const Bloom::Targets::TargetDescriptor& targetDescriptor); - }; } diff --git a/src/TargetController/TargetController.cpp b/src/TargetController/TargetController.cpp index d7ccb2de..6ce9b125 100644 --- a/src/TargetController/TargetController.cpp +++ b/src/TargetController/TargetController.cpp @@ -68,7 +68,7 @@ void TargetController::startup() { this->eventManager.registerListener(this->eventListener); // Install Bloom's udev rules if not already installed - this->checkUdevRules(); + TargetController::checkUdevRules(); // Register event handlers this->eventListener->registerCallbackForEventType( @@ -303,7 +303,7 @@ void TargetController::acquireHardware() { break; } - this->target.reset(promotedTarget.release()); + this->target = std::move(promotedTarget); this->target->postPromotionConfigure(); } @@ -360,17 +360,17 @@ void TargetController::emitErrorEvent(int correlationId) { this->eventManager.triggerEvent(errorEvent); } -void TargetController::onShutdownTargetControllerEvent(EventPointer) { +void TargetController::onShutdownTargetControllerEvent(EventRef) { this->shutdown(); } -void TargetController::onStateReportRequest(EventPointer event) { +void TargetController::onStateReportRequest(EventRef event) { auto stateEvent = std::make_shared(this->state); - stateEvent->correlationId = event->id; + stateEvent->correlationId = event.id; this->eventManager.triggerEvent(stateEvent); } -void TargetController::onDebugSessionStartedEvent(EventPointer) { +void TargetController::onDebugSessionStartedEvent(EventRef) { if (this->state == TargetControllerState::SUSPENDED) { Logger::debug("Waking TargetController"); @@ -385,7 +385,7 @@ void TargetController::onDebugSessionStartedEvent(EventPointer) { +void TargetController::onDebugSessionFinishedEvent(EventRef) { if (this->target->getState() != TargetState::RUNNING) { this->target->run(); this->fireTargetEvents(); @@ -396,7 +396,7 @@ void TargetController::onDebugSessionFinishedEvent(EventPointer event) { +void TargetController::onExtractTargetDescriptor(EventRef event) { if (!this->cachedTargetDescriptor.has_value()) { this->cachedTargetDescriptor = this->target->getDescriptor(); } @@ -404,11 +404,11 @@ void TargetController::onExtractTargetDescriptor(EventPointer(); targetDescriptorExtracted->targetDescriptor = this->cachedTargetDescriptor.value(); - targetDescriptorExtracted->correlationId = event->id; + targetDescriptorExtracted->correlationId = event.id; this->eventManager.triggerEvent(targetDescriptorExtracted); } -void TargetController::onStopTargetExecutionEvent(EventPointer event) { +void TargetController::onStopTargetExecutionEvent(EventRef event) { if (this->target->getState() != TargetState::STOPPED) { this->target->stop(); this->lastTargetState = TargetState::STOPPED; @@ -419,39 +419,39 @@ void TargetController::onStopTargetExecutionEvent(EventPointercorrelationId = event->id; + executionStoppedEvent->correlationId = event.id; this->eventManager.triggerEvent(executionStoppedEvent); } -void TargetController::onStepTargetExecutionEvent(EventPointer event) { +void TargetController::onStepTargetExecutionEvent(EventRef event) { try { if (this->target->getState() != TargetState::STOPPED) { // We can't step the target if it's already running. throw Exception("Target is already running"); } - if (event->fromProgramCounter.has_value()) { - this->target->setProgramCounter(event->fromProgramCounter.value()); + if (event.fromProgramCounter.has_value()) { + this->target->setProgramCounter(event.fromProgramCounter.value()); } this->target->step(); this->lastTargetState = TargetState::RUNNING; auto executionResumedEvent = std::make_shared(); - executionResumedEvent->correlationId = event->id; + executionResumedEvent->correlationId = event.id; this->eventManager.triggerEvent(executionResumedEvent); } catch (const Exception& exception) { Logger::error("Failed to step execution on target - " + exception.getMessage()); - this->emitErrorEvent(event->id); + this->emitErrorEvent(event.id); } } -void TargetController::onResumeTargetExecutionEvent(EventPointer event) { +void TargetController::onResumeTargetExecutionEvent(EventRef event) { try { if (this->target->getState() != TargetState::RUNNING) { - if (event->fromProgramCounter.has_value()) { - this->target->setProgramCounter(event->fromProgramCounter.value()); + if (event.fromProgramCounter.has_value()) { + this->target->setProgramCounter(event.fromProgramCounter.value()); } this->target->run(); @@ -459,72 +459,72 @@ void TargetController::onResumeTargetExecutionEvent(EventPointer(); - executionResumedEvent->correlationId = event->id; + executionResumedEvent->correlationId = event.id; this->eventManager.triggerEvent(executionResumedEvent); } catch (const Exception& exception) { Logger::error("Failed to resume execution on target - " + exception.getMessage()); - this->emitErrorEvent(event->id); + this->emitErrorEvent(event.id); } } -void TargetController::onReadRegistersEvent(EventPointer event) { +void TargetController::onReadRegistersEvent(EventRef event) { try { - auto registers = this->target->readRegisters(event->descriptors); + auto registers = this->target->readRegisters(event.descriptors); if (registers.size() > 0) { auto registersRetrievedEvent = std::make_shared(); - registersRetrievedEvent->correlationId = event->id; + registersRetrievedEvent->correlationId = event.id; registersRetrievedEvent->registers = registers; this->eventManager.triggerEvent(registersRetrievedEvent); } } catch (const Exception& exception) { Logger::error("Failed to read general registers from target - " + exception.getMessage()); - this->emitErrorEvent(event->id); + this->emitErrorEvent(event.id); } } -void TargetController::onWriteRegistersEvent(EventPointer event) { +void TargetController::onWriteRegistersEvent(EventRef event) { try { - this->target->writeRegisters(event->registers); + this->target->writeRegisters(event.registers); auto registersWrittenEvent = std::make_shared(); - registersWrittenEvent->correlationId = event->id; + registersWrittenEvent->correlationId = event.id; this->eventManager.triggerEvent(registersWrittenEvent); } catch (const Exception& exception) { Logger::error("Failed to write registers to target - " + exception.getMessage()); - this->emitErrorEvent(event->id); + this->emitErrorEvent(event.id); } } -void TargetController::onReadMemoryEvent(EventPointer event) { +void TargetController::onReadMemoryEvent(EventRef event) { try { auto memoryReadEvent = std::make_shared(); - memoryReadEvent->correlationId = event->id; - memoryReadEvent->data = this->target->readMemory(event->memoryType, event->startAddress, event->bytes); + memoryReadEvent->correlationId = event.id; + memoryReadEvent->data = this->target->readMemory(event.memoryType, event.startAddress, event.bytes); this->eventManager.triggerEvent(memoryReadEvent); } catch (const Exception& exception) { Logger::error("Failed to read memory from target - " + exception.getMessage()); - this->emitErrorEvent(event->id); + this->emitErrorEvent(event.id); } } -void TargetController::onWriteMemoryEvent(EventPointer event) { +void TargetController::onWriteMemoryEvent(EventRef event) { try { - this->target->writeMemory(event->memoryType, event->startAddress, event->buffer); + this->target->writeMemory(event.memoryType, event.startAddress, event.buffer); auto memoryWrittenEvent = std::make_shared(); - memoryWrittenEvent->correlationId = event->id; + memoryWrittenEvent->correlationId = event.id; this->eventManager.triggerEvent(memoryWrittenEvent); if (this->target->memoryAddressRangeClashesWithIoPortRegisters( - event->memoryType, - event->startAddress, - static_cast(event->startAddress + (event->buffer.size() - 1)) + event.memoryType, + event.startAddress, + static_cast(event.startAddress + (event.buffer.size() - 1)) )) { // This memory write has affected the target's IO port values this->eventManager.triggerEvent(std::make_shared()); @@ -532,59 +532,59 @@ void TargetController::onWriteMemoryEvent(EventPointeremitErrorEvent(event->id); + this->emitErrorEvent(event.id); } } -void TargetController::onSetBreakpointEvent(EventPointer event) { +void TargetController::onSetBreakpointEvent(EventRef event) { try { - this->target->setBreakpoint(event->breakpoint.address); + this->target->setBreakpoint(event.breakpoint.address); auto breakpointSetEvent = std::make_shared(); - breakpointSetEvent->correlationId = event->id; + breakpointSetEvent->correlationId = event.id; this->eventManager.triggerEvent(breakpointSetEvent); } catch (const Exception& exception) { Logger::error("Failed to set breakpoint on target - " + exception.getMessage()); - this->emitErrorEvent(event->id); + this->emitErrorEvent(event.id); } } -void TargetController::onRemoveBreakpointEvent(EventPointer event) { +void TargetController::onRemoveBreakpointEvent(EventRef event) { try { - this->target->removeBreakpoint(event->breakpoint.address); + this->target->removeBreakpoint(event.breakpoint.address); auto breakpointRemovedEvent = std::make_shared(); - breakpointRemovedEvent->correlationId = event->id; + breakpointRemovedEvent->correlationId = event.id; this->eventManager.triggerEvent(breakpointRemovedEvent); } catch (const Exception& exception) { Logger::error("Failed to remove breakpoint on target - " + exception.getMessage()); - this->emitErrorEvent(event->id); + this->emitErrorEvent(event.id); } } -void TargetController::onSetProgramCounterEvent(EventPointer event) { +void TargetController::onSetProgramCounterEvent(EventRef event) { try { if (this->target->getState() != TargetState::STOPPED) { throw Exception("Invalid target state - target must be stopped before the program counter can be updated"); } - this->target->setProgramCounter(event->address); + this->target->setProgramCounter(event.address); auto programCounterSetEvent = std::make_shared(); - programCounterSetEvent->correlationId = event->id; + programCounterSetEvent->correlationId = event.id; this->eventManager.triggerEvent(programCounterSetEvent); } catch (const Exception& exception) { Logger::error("Failed to set program counter on target - " + exception.getMessage()); - this->emitErrorEvent(event->id); + this->emitErrorEvent(event.id); } } // TODO: remove this -void TargetController::onInsightStateChangedEvent(EventPointer event) { - if (event->getState() == ThreadState::READY) { +void TargetController::onInsightStateChangedEvent(EventRef event) { + if (event.getState() == ThreadState::READY) { /* * Insight has just started up. * @@ -595,45 +595,45 @@ void TargetController::onInsightStateChangedEvent(EventPointer event) { +void TargetController::onRetrieveTargetPinStatesEvent(EventRef event) { try { if (this->target->getState() != TargetState::STOPPED) { throw Exception("Invalid target state - target must be stopped before pin states can be retrieved"); } auto pinStatesRetrieved = std::make_shared(); - pinStatesRetrieved->correlationId = event->id; - pinStatesRetrieved->variantId = event->variantId; - pinStatesRetrieved->pinSatesByNumber = this->target->getPinStates(event->variantId); + pinStatesRetrieved->correlationId = event.id; + pinStatesRetrieved->variantId = event.variantId; + pinStatesRetrieved->pinSatesByNumber = this->target->getPinStates(event.variantId); this->eventManager.triggerEvent(pinStatesRetrieved); } catch (const Exception& exception) { Logger::error("Failed to retrieve target pin states - " + exception.getMessage()); - this->emitErrorEvent(event->id); + this->emitErrorEvent(event.id); } } -void TargetController::onSetPinStateEvent(EventPointer event) { +void TargetController::onSetPinStateEvent(EventRef event) { try { if (this->target->getState() != TargetState::STOPPED) { throw Exception("Invalid target state - target must be stopped before pin state can be set"); } - this->target->setPinState(event->variantId, event->pinDescriptor, event->pinState); + this->target->setPinState(event.variantId, event.pinDescriptor, event.pinState); auto pinStatesUpdateEvent = std::make_shared(); - pinStatesUpdateEvent->correlationId = event->id; - pinStatesUpdateEvent->variantId = event->variantId; + pinStatesUpdateEvent->correlationId = event.id; + pinStatesUpdateEvent->variantId = event.variantId; pinStatesUpdateEvent->pinSatesByNumber = { - {event->pinDescriptor.number, event->pinState} + {event.pinDescriptor.number, event.pinState} }; this->eventManager.triggerEvent(pinStatesUpdateEvent); } catch (const Exception& exception) { - Logger::error("Failed to set target pin state for pin " + event->pinDescriptor.name + " - " + Logger::error("Failed to set target pin state for pin " + event.pinDescriptor.name + " - " + exception.getMessage()); - this->emitErrorEvent(event->id); + this->emitErrorEvent(event.id); } } diff --git a/src/TargetController/TargetController.hpp b/src/TargetController/TargetController.hpp index 5575e69c..d3c42617 100644 --- a/src/TargetController/TargetController.hpp +++ b/src/TargetController/TargetController.hpp @@ -67,7 +67,7 @@ namespace Bloom /** * Constructs a mapping of supported debug tool names to lambdas. The lambdas should *only* instantiate - * and return an instance to the derived DebugTool class. They should never attempt to establish + * and return an instance to the derived DebugTool class. They should not attempt to establish * a connection to the device. * * @return @@ -173,7 +173,7 @@ namespace Bloom * to /etc/udev/rules.d/. This method will report an error if Bloom isn't running as root (as root privileges * are required for writing to files in /etc/udev). */ - void checkUdevRules(); + static void checkUdevRules(); /** * Because the TargetController hogs the thread, this method must be called in a dedicated thread. @@ -244,70 +244,70 @@ namespace Bloom * * @param event */ - void onStateReportRequest(Events::EventPointer event); + void onStateReportRequest(Events::EventRef event); /** * Obtains a TargetDescriptor from the target and includes it in a TargetDescriptorExtracted event. * * @param event */ - void onExtractTargetDescriptor(Events::EventPointer event); + void onExtractTargetDescriptor(Events::EventRef event); /** * Will attempt to stop execution on the target and emit a TargetExecutionStopped event. * * @param event */ - void onStopTargetExecutionEvent(Events::EventPointer event); + void onStopTargetExecutionEvent(Events::EventRef event); /** * Will attempt to step execution on the target and emit a TargetExecutionResumed event. * * @param event */ - void onStepTargetExecutionEvent(Events::EventPointer event); + void onStepTargetExecutionEvent(Events::EventRef event); /** * Will attempt to resume execution on the target and emit a TargetExecutionResumed event. * * @param event */ - void onResumeTargetExecutionEvent(Events::EventPointer event); + void onResumeTargetExecutionEvent(Events::EventRef event); /** * Invokes a shutdown. * * @param event */ - void onShutdownTargetControllerEvent(Events::EventPointer event); + void onShutdownTargetControllerEvent(Events::EventRef event); /** * Will attempt to read the requested registers and emit a RegistersRetrievedFromTarget event. * * @param event */ - void onReadRegistersEvent(Events::EventPointer event); + void onReadRegistersEvent(Events::EventRef event); /** * Will attempt to write the specified register values and emit a RegistersWrittenToTarget event. * * @param event */ - void onWriteRegistersEvent(Events::EventPointer event); + void onWriteRegistersEvent(Events::EventRef event); /** * Will attempt to read memory from the target and include the data in a MemoryRetrievedFromTarget event. * * @param event */ - void onReadMemoryEvent(Events::EventPointer event); + void onReadMemoryEvent(Events::EventRef event); /** * Will attempt to write memory to the target. On success, a MemoryWrittenToTarget event is emitted. * * @param event */ - void onWriteMemoryEvent(Events::EventPointer event); + void onWriteMemoryEvent(Events::EventRef event); /** * Will attempt to set the specific breakpoint on the target. On success, the BreakpointSetOnTarget event will @@ -315,7 +315,7 @@ namespace Bloom * * @param event */ - void onSetBreakpointEvent(Events::EventPointer event); + void onSetBreakpointEvent(Events::EventRef event); /** * Will attempt to remove a breakpoint at the specified address, on the target. On success, the @@ -323,21 +323,21 @@ namespace Bloom * * @param event */ - void onRemoveBreakpointEvent(Events::EventPointer event); + void onRemoveBreakpointEvent(Events::EventRef event); /** * Will hold the target stopped at it's current state. * * @param event */ - void onDebugSessionStartedEvent(Events::EventPointer event); + void onDebugSessionStartedEvent(Events::EventRef event); /** * Will simply kick off execution on the target. * * @param event */ - void onDebugSessionFinishedEvent(Events::EventPointer event); + void onDebugSessionFinishedEvent(Events::EventRef event); /** * Will update the program counter value on the target. On success, a ProgramCounterSetOnTarget event is @@ -345,7 +345,7 @@ namespace Bloom * * @param event */ - void onSetProgramCounterEvent(Events::EventPointer event); + void onSetProgramCounterEvent(Events::EventRef event); /** * Will automatically fire a target state update event. @@ -353,14 +353,14 @@ namespace Bloom * * @param event */ - void onInsightStateChangedEvent(Events::EventPointer event); + void onInsightStateChangedEvent(Events::EventRef event); /** * Will attempt to obtain the pin states from the target. Will emit a TargetPinStatesRetrieved event on success. * * @param event */ - void onRetrieveTargetPinStatesEvent(Events::EventPointer event); + void onRetrieveTargetPinStatesEvent(Events::EventRef event); /** * Will update a pin state for a particular pin. Will emit a TargetPinStatesRetrieved with the new pin @@ -368,6 +368,6 @@ namespace Bloom * * @param event */ - void onSetPinStateEvent(Events::EventPointer event); + void onSetPinStateEvent(Events::EventRef event); }; } diff --git a/src/TargetController/TargetControllerConsole.cpp b/src/TargetController/TargetControllerConsole.cpp index 7b8a228c..2f3ed66e 100644 --- a/src/TargetController/TargetControllerConsole.cpp +++ b/src/TargetController/TargetControllerConsole.cpp @@ -18,12 +18,12 @@ TargetControllerState TargetControllerConsole::getTargetControllerState() { >(this->defaultTimeout, getStateEvent->id); if (!responseEvent.has_value() - || !std::holds_alternative>(responseEvent.value()) + || !std::holds_alternative>(responseEvent.value()) ) { throw Exception("Unexpected response from TargetController"); } - auto stateReportedEvent = std::get>(responseEvent.value()); + auto stateReportedEvent = std::get>(responseEvent.value()); return stateReportedEvent->state; } @@ -45,12 +45,12 @@ Targets::TargetDescriptor TargetControllerConsole::getTargetDescriptor() { >(this->defaultTimeout, extractEvent->id); if (!responseEvent.has_value() - || !std::holds_alternative>(responseEvent.value()) + || !std::holds_alternative>(responseEvent.value()) ) { throw Exception("Unexpected response from TargetController"); } - auto descriptorExtracted = std::get>(responseEvent.value()); + auto descriptorExtracted = std::get>(responseEvent.value()); return descriptorExtracted->targetDescriptor; } @@ -64,7 +64,7 @@ void TargetControllerConsole::stopTargetExecution() { >(this->defaultTimeout, stopTargetEvent->id); if (!responseEvent.has_value() - || !std::holds_alternative>(responseEvent.value()) + || !std::holds_alternative>(responseEvent.value()) ) { throw Exception("Unexpected response from TargetController"); } @@ -84,7 +84,7 @@ void TargetControllerConsole::continueTargetExecution(std::optional(this->defaultTimeout, resumeExecutionEvent->id); if (!responseEvent.has_value() - || !std::holds_alternative>(responseEvent.value()) + || !std::holds_alternative>(responseEvent.value()) ) { throw Exception("Unexpected response from TargetController"); } @@ -104,7 +104,7 @@ void TargetControllerConsole::stepTargetExecution(std::optional f >(this->defaultTimeout, stepExecutionEvent->id); if (!responseEvent.has_value() - || !std::holds_alternative>(responseEvent.value()) + || !std::holds_alternative>(responseEvent.value()) ) { throw Exception("Unexpected response from TargetController"); } @@ -121,12 +121,14 @@ TargetRegisters TargetControllerConsole::readGeneralRegisters(TargetRegisterDesc >(this->defaultTimeout, readRegistersEvent->id); if (!responseEvent.has_value() - || !std::holds_alternative>(responseEvent.value()) + || !std::holds_alternative>(responseEvent.value()) ) { throw Exception("Unexpected response from TargetController"); } - auto retrievedRegistersEvent = std::get>(responseEvent.value()); + auto retrievedRegistersEvent = std::get>( + responseEvent.value() + ); return retrievedRegistersEvent->registers; } @@ -141,7 +143,7 @@ void TargetControllerConsole::writeGeneralRegisters(TargetRegisters registers) { >(this->defaultTimeout, event->id); if (!responseEvent.has_value() - || !std::holds_alternative>(responseEvent.value()) + || !std::holds_alternative>(responseEvent.value()) ) { throw Exception("Unexpected response from TargetController"); } @@ -164,12 +166,14 @@ TargetMemoryBuffer TargetControllerConsole::readMemory( >(this->defaultTimeout, readMemoryEvent->id); if (!responseEvent.has_value() - || !std::holds_alternative>(responseEvent.value()) + || !std::holds_alternative>(responseEvent.value()) ) { throw Exception("Unexpected response from TargetController"); } - auto retrievedRegistersEvent = std::get>(responseEvent.value()); + auto retrievedRegistersEvent = std::get>( + responseEvent.value() + ); return retrievedRegistersEvent->data; } @@ -190,7 +194,7 @@ void TargetControllerConsole::writeMemory( >(this->defaultTimeout, writeMemoryEvent->id); if (!responseEvent.has_value() - || !std::holds_alternative>(responseEvent.value()) + || !std::holds_alternative>(responseEvent.value()) ) { throw Exception("Unexpected response from TargetController"); } @@ -207,7 +211,7 @@ void TargetControllerConsole::setBreakpoint(TargetBreakpoint breakpoint) { >(this->defaultTimeout, event->id); if (!responseEvent.has_value() - || !std::holds_alternative>(responseEvent.value()) + || !std::holds_alternative>(responseEvent.value()) ) { throw Exception("Unexpected response from TargetController"); } @@ -224,7 +228,7 @@ void TargetControllerConsole::removeBreakpoint(TargetBreakpoint breakpoint) { >(this->defaultTimeout, event->id); if (!responseEvent.has_value() - || !std::holds_alternative>(responseEvent.value()) + || !std::holds_alternative>(responseEvent.value()) ) { throw Exception("Unexpected response from TargetController"); } @@ -240,7 +244,7 @@ void TargetControllerConsole::requestPinStates(int variantId) { void TargetControllerConsole::setPinState(int variantId, TargetPinDescriptor pinDescriptor, TargetPinState pinState) { auto updateEvent = std::make_shared(); updateEvent->variantId = variantId; - updateEvent->pinDescriptor = pinDescriptor; + updateEvent->pinDescriptor = std::move(pinDescriptor); updateEvent->pinState = pinState; this->eventManager.triggerEvent(updateEvent);