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

Replaced RetrieveMemoryFromTarget event with TC command

Browse Source
This commit is contained in:
Nav
2022-04-24 18:55:19 +01:00
parent 6e4364b43a
commit 391b742d8b
11 changed files with 97 additions and 99 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -29,8 +29,6 @@ namespace Bloom::Events
REGISTERS_WRITTEN_TO_TARGET,
TARGET_EXECUTION_RESUMED,
TARGET_EXECUTION_STOPPED,
RETRIEVE_MEMORY_FROM_TARGET,
MEMORY_RETRIEVED_FROM_TARGET,
WRITE_MEMORY_TO_TARGET,
MEMORY_WRITTEN_TO_TARGET,
SET_BREAKPOINT_ON_TARGET,

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

@@ -16,8 +16,6 @@
#include "RegistersWrittenToTarget.hpp"
#include "TargetExecutionResumed.hpp"
#include "TargetExecutionStopped.hpp"
#include "RetrieveMemoryFromTarget.hpp"
#include "MemoryRetrievedFromTarget.hpp"
#include "WriteMemoryToTarget.hpp"
#include "MemoryWrittenToTarget.hpp"
#include "SetBreakpointOnTarget.hpp"

25
src/EventManager/Events/MemoryRetrievedFromTarget.hpp
View File

@@ -1,25 +0,0 @@
#pragma once
#include <string>
#include "Event.hpp"
#include "src/Targets/TargetMemory.hpp"
namespace Bloom::Events
{
class MemoryRetrievedFromTarget: public Event
{
public:
static constexpr EventType type = EventType::MEMORY_RETRIEVED_FROM_TARGET;
static inline const std::string name = "MemoryRetrievedFromTarget";
Targets::TargetMemoryBuffer data;
[[nodiscard]] EventType getType() const override {
return MemoryRetrievedFromTarget::type;
}
[[nodiscard]] std::string getName() const override {
return MemoryRetrievedFromTarget::name;
}
};
}

32
src/EventManager/Events/RetrieveMemoryFromTarget.hpp
View File

@@ -1,32 +0,0 @@
#pragma once
#include <cstdint>
#include <string>
#include "Event.hpp"
#include "MemoryRetrievedFromTarget.hpp"
#include "src/Targets/TargetMemory.hpp"
namespace Bloom::Events
{
class RetrieveMemoryFromTarget: public Event
{
public:
using TargetControllerResponseType = MemoryRetrievedFromTarget;
static constexpr EventType type = EventType::RETRIEVE_MEMORY_FROM_TARGET;
static inline const std::string name = "RetrieveMemoryFromTarget";
Targets::TargetMemoryType memoryType = Targets::TargetMemoryType::RAM;
std::uint32_t startAddress = 0;
std::uint32_t bytes = 0;
std::set<Targets::TargetMemoryAddressRange> excludedAddressRanges;
[[nodiscard]] EventType getType() const override {
return RetrieveMemoryFromTarget::type;
}
[[nodiscard]] std::string getName() const override {
return RetrieveMemoryFromTarget::name;
}
};
}

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

@@ -12,5 +12,6 @@ namespace Bloom::TargetController::Commands
RESET_TARGET,
READ_TARGET_REGISTERS,
WRITE_TARGET_REGISTERS,
READ_TARGET_MEMORY,
};
}

41
src/TargetController/Commands/ReadTargetMemory.hpp Normal file
View File

@@ -0,0 +1,41 @@
#pragma once
#include <optional>
#include "Command.hpp"
#include "src/TargetController/Responses/TargetMemoryRead.hpp"
#include "src/Targets/TargetRegister.hpp"
namespace Bloom::TargetController::Commands
{
class ReadTargetMemory: public Command
{
public:
using SuccessResponseType = Responses::TargetMemoryRead;
static constexpr CommandType type = CommandType::READ_TARGET_MEMORY;
static inline const std::string name = "ReadTargetMemory";
Targets::TargetMemoryType memoryType;
std::uint32_t startAddress;
std::uint32_t bytes;
std::set<Targets::TargetMemoryAddressRange> excludedAddressRanges;
explicit ReadTargetMemory(
Targets::TargetMemoryType memoryType,
std::uint32_t startAddress,
std::uint32_t bytes,
const std::set<Targets::TargetMemoryAddressRange>& excludedAddressRanges
)
: memoryType(memoryType)
, startAddress(startAddress)
, bytes(bytes)
, excludedAddressRanges(excludedAddressRanges)
{};
[[nodiscard]] CommandType getType() const override {
return ReadTargetMemory::type;
}
};
}

1
src/TargetController/Responses/ResponseTypes.hpp
View File

@@ -9,5 +9,6 @@ namespace Bloom::TargetController::Responses
GENERIC,
ERROR,
TARGET_REGISTERS_READ,
TARGET_MEMORY_READ,
};
}

24
src/TargetController/Responses/TargetMemoryRead.hpp Normal file
View File

@@ -0,0 +1,24 @@
#pragma once
#include "Response.hpp"
#include "src/Targets/TargetMemory.hpp"
namespace Bloom::TargetController::Responses
{
class TargetMemoryRead: public Response
{
public:
static constexpr ResponseType type = ResponseType::TARGET_MEMORY_READ;
Targets::TargetMemoryBuffer data;
TargetMemoryRead(const Targets::TargetMemoryBuffer& data)
: data(data)
{}
[[nodiscard]] ResponseType getType() const override {
return TargetMemoryRead::type;
}
};
}

40
src/TargetController/TargetControllerComponent.cpp
View File

@@ -27,9 +27,11 @@ namespace Bloom::TargetController
using Commands::ResetTarget;
using Commands::ReadTargetRegisters;
using Commands::WriteTargetRegisters;
using Commands::ReadTargetMemory;
using Responses::Response;
using Responses::TargetRegistersRead;
using Responses::TargetMemoryRead;
TargetControllerComponent::TargetControllerComponent(
const ProjectConfig& projectConfig,
@@ -379,11 +381,11 @@ namespace Bloom::TargetController
this->deregisterCommandHandler(ResetTarget::type);
this->deregisterCommandHandler(ReadTargetRegisters::type);
this->deregisterCommandHandler(WriteTargetRegisters::type);
this->deregisterCommandHandler(ReadTargetMemory::type);
this->eventListener->deregisterCallbacksForEventType<Events::DebugSessionFinished>();
this->eventListener->deregisterCallbacksForEventType<Events::ExtractTargetDescriptor>();
this->eventListener->deregisterCallbacksForEventType<Events::StepTargetExecution>();
this->eventListener->deregisterCallbacksForEventType<Events::RetrieveMemoryFromTarget>();
this->eventListener->deregisterCallbacksForEventType<Events::WriteMemoryToTarget>();
this->eventListener->deregisterCallbacksForEventType<Events::SetBreakpointOnTarget>();
this->eventListener->deregisterCallbacksForEventType<Events::RemoveBreakpointOnTarget>();
@@ -428,6 +430,10 @@ namespace Bloom::TargetController
std::bind(&TargetControllerComponent::handleWriteTargetRegisters, this, std::placeholders::_1)
);
this->registerCommandHandler<ReadTargetMemory>(
std::bind(&TargetControllerComponent::handleReadTargetMemory, this, std::placeholders::_1)
);
this->eventListener->registerCallbackForEventType<Events::DebugSessionFinished>(
std::bind(&TargetControllerComponent::onDebugSessionFinishedEvent, this, std::placeholders::_1)
);
@@ -440,10 +446,6 @@ namespace Bloom::TargetController
std::bind(&TargetControllerComponent::onStepTargetExecutionEvent, this, std::placeholders::_1)
);
this->eventListener->registerCallbackForEventType<Events::RetrieveMemoryFromTarget>(
std::bind(&TargetControllerComponent::onReadMemoryEvent, this, std::placeholders::_1)
);
this->eventListener->registerCallbackForEventType<Events::WriteMemoryToTarget>(
std::bind(&TargetControllerComponent::onWriteMemoryEvent, this, std::placeholders::_1)
);
@@ -783,6 +785,15 @@ namespace Bloom::TargetController
return std::make_unique<Response>();
}
std::unique_ptr<TargetMemoryRead> TargetControllerComponent::handleReadTargetMemory(ReadTargetMemory& command) {
return std::make_unique<TargetMemoryRead>(this->target->readMemory(
command.memoryType,
command.startAddress,
command.bytes,
command.excludedAddressRanges
));
}
void TargetControllerComponent::onStepTargetExecutionEvent(const Events::StepTargetExecution& event) {
try {
if (this->target->getState() != TargetState::STOPPED) {
@@ -807,25 +818,6 @@ namespace Bloom::TargetController
}
}
void TargetControllerComponent::onReadMemoryEvent(const Events::RetrieveMemoryFromTarget& event) {
try {
auto memoryReadEvent = std::make_shared<Events::MemoryRetrievedFromTarget>();
memoryReadEvent->correlationId = event.id;
memoryReadEvent->data = this->target->readMemory(
event.memoryType,
event.startAddress,
event.bytes,
event.excludedAddressRanges
);
EventManager::triggerEvent(memoryReadEvent);
} catch (const TargetOperationFailure& exception) {
Logger::error("Failed to read memory from target - " + exception.getMessage());
this->emitErrorEvent(event.id, exception.getMessage());
}
}
void TargetControllerComponent::onWriteMemoryEvent(const Events::WriteMemoryToTarget& event) {
try {
const auto& buffer = event.buffer;

10
src/TargetController/TargetControllerComponent.hpp
View File

@@ -22,10 +22,12 @@
#include "Commands/ResetTarget.hpp"
#include "Commands/ReadTargetRegisters.hpp"
#include "Commands/WriteTargetRegisters.hpp"
#include "Commands/ReadTargetMemory.hpp"
// Responses
#include "Responses/Response.hpp"
#include "Responses/TargetRegistersRead.hpp"
#include "Responses/TargetMemoryRead.hpp"
#include "TargetControllerState.hpp"
@@ -298,6 +300,7 @@ namespace Bloom::TargetController
Commands::ReadTargetRegisters& command
);
std::unique_ptr<Responses::Response> handleWriteTargetRegisters(Commands::WriteTargetRegisters& command);
std::unique_ptr<Responses::TargetMemoryRead> handleReadTargetMemory(Commands::ReadTargetMemory& command);
/**
* Will attempt to step execution on the target and emit a TargetExecutionResumed event.
@@ -306,13 +309,6 @@ namespace Bloom::TargetController
*/
void onStepTargetExecutionEvent(const Events::StepTargetExecution& event);
/**
* Will attempt to read memory from the target and include the data in a MemoryRetrievedFromTarget event.
*
* @param event
*/
void onReadMemoryEvent(const Events::RetrieveMemoryFromTarget& event);
/**
* Will attempt to write memory to the target. On success, a MemoryWrittenToTarget event is emitted.
*

18
src/TargetController/TargetControllerConsole.cpp
View File

@@ -8,6 +8,7 @@
#include "Commands/ResetTarget.hpp"
#include "Commands/ReadTargetRegisters.hpp"
#include "Commands/WriteTargetRegisters.hpp"
#include "Commands/ReadTargetMemory.hpp"
#include "src/Logger/Logger.hpp"
@@ -22,6 +23,7 @@ namespace Bloom::TargetController
using Commands::ResetTarget;
using Commands::ReadTargetRegisters;
using Commands::WriteTargetRegisters;
using Commands::ReadTargetMemory;
TargetControllerConsole::TargetControllerConsole(EventListener& eventListener)
: eventListener(eventListener)
@@ -98,13 +100,15 @@ namespace Bloom::TargetController
std::uint32_t bytes,
const std::set<Targets::TargetMemoryAddressRange>& excludedAddressRanges
) {
auto readMemoryEvent = std::make_shared<RetrieveMemoryFromTarget>();
readMemoryEvent->memoryType = memoryType;
readMemoryEvent->startAddress = startAddress;
readMemoryEvent->bytes = bytes;
readMemoryEvent->excludedAddressRanges = excludedAddressRanges;
return this->triggerTargetControllerEventAndWaitForResponse(readMemoryEvent)->data;
return this->commandManager.sendCommandAndWaitForResponse(
std::make_unique<ReadTargetMemory>(
memoryType,
startAddress,
bytes,
excludedAddressRanges
),
this->defaultTimeout
)->data;
}
void TargetControllerConsole::writeMemory(